#########################################################
## WD já setado via abertura do projeto
setwd("~/R/explorar set2025")
## zera todos os objetos
##rm(list = ls()) 

# modificações feitas neste script são localizadas com 
#  a pesquisa do texto "explorar:"

#######################################################
# reinstalação de pacotes QCA - feita em 27mar2025
# do script do Patrick Mello
#install.packages("QCA")
#install.packages("SetMethods")
#install.packages("readxl")
library("QCA")
library("SetMethods")
# do script do Adrian na disciplina
library(dplyr) # data transformation
library(tibble) # column to rownames
library(devtools) # session info and parameters
library(formattable) # nicer truth tables
# para ler arquivos xls
library(readxl)
# para gravar arquivos xls (com limitações)
library(writexl)

#  não foi utilizado o pacote vdemdata, porque somente roda com
#   uma versão anterior do R (4.2.2). A manipulação dos dados V-Dem
#   foi feita diretamente
#######################################################3

#  soluções de emergência
# se rodar em outro ambiente: usar comando setwd
#  se der pau na leitura direta do xls, converter arquivos de 
#  entrada excel em csv e usar no estilo:
#                  modelo = read.csv("Polity V.csv", header = TRUE, sep = ";")


#################################################################
########################### funções pré-programadas
#################################################################
#### nome.funcao <- function(parm.funcao)
####   {  #begin function
#### comandos da funcao  
#### return (resultado.funcao) 
####  fim da função
####   }  #endfunction

############ se precisar testar o arquivo de entrada com o para checar e corrigir  registros 
############ fora da ordem de ano/país, usar o script auxiliar "Confere ordem dos registros" 


#####
############  função calcula subtotais
#####
#  subtotais de até 5 colunas, estruturados pela primeira coluna

calcula.subtotais <- function(parm.chave, parm.subtotal1, parm.subtotal2,
                              parm.subtotal3, parm.subtotal4, parm.subtotal5)
  #                              parm.chave é um vetor com os dados da coluna pela qual vão ser gerados os subtotais
  #                              parm.subtotais são vetores com os dados de até 5 colunas cujos valores serão somados
  #                              - se algum parm.subtotal for NA, não é acumulado e a coluna correspondente volta com NA    
  #                              - a saída é um dataframe com a primeira coluna com os valores não-repetidos da chave
  #                              e as demais cinco com os subtotais daquelas que foram fornecidas na entrada    
  ############        ==> esta função não sorta as colunas de entrada, o subtotal é gerado
  #                      a partir da ordem em que é recebida a coluna de chave
  
  
{  #begin function
  
  
  
  #  primeiro registro
  
  
  chave.anterior <- as.character(parm.chave [1])
  subtotal1 <- as.numeric(parm.subtotal1 [1])
  subtotal2 <- as.numeric(parm.subtotal2 [1])
  subtotal3 <- as.numeric(parm.subtotal3 [1])
  subtotal4 <- as.numeric(parm.subtotal4 [1])
  subtotal5 <- as.numeric(parm.subtotal5 [1])
  
  # controla a primeira gravacao
  ind.primeira.gravacao <- 1
  
  for (k in 2:length(parm.chave))
  {
    #     não mudou a chave - apenas acumula subtotais diferentes de NA
    if (as.character(parm.chave [k]) == chave.anterior)
    {
      if (! is.na (parm.subtotal1 [k]) )
      { subtotal1 = subtotal1 + as.numeric(parm.subtotal1 [k])}
      if (! is.na (parm.subtotal2 [k]) )
      { subtotal2 = subtotal2 + as.numeric(parm.subtotal2 [k])}
      if (! is.na (parm.subtotal3 [k]) )
      { subtotal3 = subtotal3 + as.numeric(parm.subtotal3 [k])}
      if (! is.na (parm.subtotal4 [k]) )
      { subtotal4 = subtotal4 + as.numeric(parm.subtotal4 [k])}
      if (! is.na (parm.subtotal5 [k]) )
      { subtotal5 = subtotal5 + as.numeric(parm.subtotal5 [k])}
    }
    else
      #     mudou a chave - carrega o registro no dataframe de saída,
      #     reinicializa os acumuladores e o controle de chave anterior
    {
      
      if (ind.primeira.gravacao == 1)
      {
        saida.subtotais <- data.frame (CHAVE = parm.chave [1], SUBTL1 = subtotal1,
                                       SUBTL1 = subtotal2 ,SUBTL3 = subtotal3,
                                       SUBTL4 = subtotal4,SUBTL5 = subtotal5)
        ind.primeira.gravacao <- 0
      }
      else
      {
        novo.registro.saida <- c (parm.chave [k - 1], subtotal1,
                                  subtotal2, subtotal3,
                                  subtotal4, subtotal5)
        
        saida.subtotais <- rbind (saida.subtotais, novo.registro.saida)
      }
      
      chave.anterior <- as.character(parm.chave [k])
      subtotal1 <- as.numeric(parm.subtotal1 [k])
      subtotal2 <- as.numeric(parm.subtotal2 [k])
      subtotal3 <- as.numeric(parm.subtotal3 [k])
      subtotal4 <- as.numeric(parm.subtotal4 [k])
      subtotal5 <- as.numeric(parm.subtotal5 [k])
      
    }
  }  # end for
  #  último registro (saiu do loop)
  #  se não mudou em relação ao valor da chave anterior, salva com
  #  o valor dos acumuladores
  if (as.character(parm.chave [k]) == chave.anterior)
  {
    novo.registro.saida <- c (parm.chave [k - 1], subtotal1,
                              subtotal2, subtotal3,
                              subtotal4, subtotal5)
    saida.subtotais <- rbind (saida.subtotais, novo.registro.saida)
  }
  #  se  mudou em relação ao valor da chave anterior, salva primeiro 
  #  o valor acumulado até o registro anterior, e em seguida outra linha com
  #  o valor do próprio último registro
  
  else
  {
    novo.registro.saida <- c (parm.chave [k - 1], subtotal1,
                              subtotal2, subtotal3,
                              subtotal4, subtotal5)
    saida.subtotais <- rbind (saida.subtotais, novo.registro.saida)
    
    novo.registro.saida <- c (parm.chave [k], as.numeric(parm.subtotal1 [k]),
                              as.numeric(parm.subtotal2), as.numeric(parm.subtotal3),
                              as.numeric(parm.subtotal4), as.numeric(parm.subtotal5) )
    
    saida.subtotais <- rbind (saida.subtotais, novo.registro.saida)
  }
  
  return (saida.subtotais) 
  #  fim da função
}  #endfunction

#####
############  função converte nome país para código internet
#####

#  converte do nome do pais para o codigo de 2 digitos da internet
converte.nomeingles.codigo <- function(nomeingles)
{
  codigo = NA
  if (( nomeingles ==     "Argentina" ) | ( nomeingles ==  "ARGENTINA" ))
  { codigo = "AR"}
  if (( nomeingles ==     "Bolivia") | ( nomeingles == "BOLIVIA"))
  { codigo = "BO"}
  if (( nomeingles ==     "Brazil") | ( nomeingles == "BRAZIL"))
  { codigo = "BR"}
  if (( nomeingles ==     "Chile")  | ( nomeingles == "CHILE"))
  { codigo = "CL"}
  if (( nomeingles ==     "Colombia")  | ( nomeingles =="COLOMBIA"))
  { codigo = "CO"}
  if (( nomeingles ==     "Costa Rica")  | (nomeingles == "COSTA RICA"))
  { codigo = "CR"}
  if (( nomeingles ==     "Dominican Republic")  | ( nomeingles == "DOMINICAN REPUBLIC"))
  { codigo = "DR"}
  if (( nomeingles ==     "El Salvador")  | ( nomeingles == "EL SALVADOR"))
  { codigo = "SV"}
  if (( nomeingles ==     "Guatemala")  | ( nomeingles == "GUATEMALA"))
  { codigo = "GT"}
  if (( nomeingles ==     "Honduras")  | ( nomeingles == "HONDURAS"))
  { codigo = "HN"}
  if (( nomeingles ==     "Mexico")  | ( nomeingles == "MEXICO"))
  { codigo = "MX"}
  if (( nomeingles ==     "Nicaragua")  | ( nomeingles == "NICARAGUA"))
  { codigo = "NI"}
  if (( nomeingles ==     "Panama")  | ( nomeingles == "PANAMA"))
  { codigo = "PA"}
  if (( nomeingles ==     "Paraguay")  | ( nomeingles == "PARAGUAY"))
  { codigo = "PY"}
  if ( ( nomeingles ==     "Peru")  | ( nomeingles == "PERU"))
  { codigo = "PE"}
  if (( nomeingles ==     "Uruguay")  | ( nomeingles == "URUGUAY"))
  { codigo = "UY"}
  if (( nomeingles ==     "Venezuela")  | ( nomeingles == "VENEZUELA") | (nomeingles == "Venezuela, RB") | ( nomeingles == "Venezuela, Bolivarian Republic of") )
  { codigo = "VE"}
  return (codigo)
}

#####
############  função abre listas pais.ano de uma para duas dimensões
#####

#  desdobra listas pais-ano em duas dimensoes no padrão de carga ()

desdobra.lista.pais.ano <- function(parm.lista.pais.ano)
  #                              lista.pais.ano é uma variável de entrada com três colunas: país (cod. inernet),
  #                              ano (4 digitos) e o valor do dado em questão 
  #                              - a saída é uma planilha com o ano (ordenado) na primeira coluna, o país como 
  #                                título da linha (na sequência da estrutura-padrão da planilha), e o dado nas colunas
{  
  #   cria a saída na formatação padrão bidimensional ano x pais
  carga.padrao = read_xls("estrutura padrão.xls")
  lista.pais.ano = parm.lista.pais.ano
  
  for (k in 1:nrow(lista.pais.ano))
  {
    for (i in 1:nrow(carga.padrao)) 
    { 
      for (j in 2:ncol(carga.padrao))
      {
        if ( 
          (lista.pais.ano [k,1] == names (carga.padrao [j])
           &
           (lista.pais.ano [k,2] ==  carga.padrao [i,1])
          )
        )
        { carga.padrao [i,j] = lista.pais.ano [k,3] } 
      }
    }  
  }
  return (carga.padrao)
}

#  cria indicador de ordenação por código de país na internet
cria.indicador.ordenacao <- function(parm.cod.pais.internet)
{
  indicador.ordenacao = NA
  aux.ordenacao = parm.cod.pais.internet
  
  if ( aux.ordenacao ==     "AR" )
  { indicador.ordenacao = 1}
  if ( aux.ordenacao ==     "BO" )
  { indicador.ordenacao = 2}
  if ( aux.ordenacao ==     "BR" )
  { indicador.ordenacao = 3}
  if ( aux.ordenacao ==     "CL" )
  { indicador.ordenacao = 4}
  if ( aux.ordenacao ==     "CO" )
  { indicador.ordenacao = 5}
  if ( aux.ordenacao ==     "CR" )
  { indicador.ordenacao = 6}
  if ( aux.ordenacao ==     "DR" )
  { indicador.ordenacao = 7}
  if ( aux.ordenacao ==     "SV" )
  { indicador.ordenacao = 8}
  if ( aux.ordenacao ==     "GT" )
  { indicador.ordenacao = 9}
  if ( aux.ordenacao ==     "HN" )
  { indicador.ordenacao = 10}
  if ( aux.ordenacao ==     "MX" )
  { indicador.ordenacao = 11}
  if ( aux.ordenacao ==     "NI" )
  { indicador.ordenacao = 12}
  if ( aux.ordenacao ==     "PA" )
  { indicador.ordenacao = 13}
  if ( aux.ordenacao ==     "PY" )
  { indicador.ordenacao = 14}
  if ( aux.ordenacao ==     "PE" )
  { indicador.ordenacao = 15}
  if ( aux.ordenacao ==     "UY" )
  { indicador.ordenacao = 16}
  if ( aux.ordenacao ==     "VE" )
  { indicador.ordenacao = 17}
  return (indicador.ordenacao)
}  


#####
############  função reverte listas pais.ano bidimensionais para uma lista linear ordenada
#####


#  reverte listas pais-ano bidimensionais para listas lineares ordenadas ()

reverte.lista.pais.ano <- function(parm.lista.padrao)
  #                              a saída (lista.pais.ano) é um dataframe com três colunas: país (cod. inernet),
  #                              ano (4 digitos) e o valor do dado em questão 
  #                              - lista-padrao é um dataframe com o ano (ordenado) na primeira coluna, o país como 
  #                                título da linha, e o dado nas colunas
{  
  
  #   reverte a saída em  formatação padrão bidimensional ano x pais para uma lista bidimensional
  
  lista.padrao = parm.lista.padrao
  
  lista.pais.ano = data.frame (pais  = c("c1", "c2"), ano = c("y1", "y2"),dado = c (99, 99), 
                               ind.ordenacao = c (99,99) )
  
  cod.pais = colnames(lista.padrao) 
  
  k = 1
  for (i in 1:nrow(lista.padrao)) 
  { 
    for (j in 2:ncol(lista.padrao))
    {
      lista.pais.ano [k,1] = cod.pais [j]
      lista.pais.ano [k,2] = lista.padrao [i,1]
      lista.pais.ano [k,3] = lista.padrao [i,j]
      lista.pais.ano [k,4] = cria.indicador.ordenacao (lista.pais.ano [k,1])
      
      k = k +1
    }  
  }
  
  lista.pais.ano = lista.pais.ano [order (lista.pais.ano$ind.ordenacao, lista.pais.ano$ano),]
  lista.pais.ano = lista.pais.ano [c ("pais", "ano", "dado")]
  row.names(lista.pais.ano)= NULL
  return (lista.pais.ano)
  # para testar a função
  #estrutura.padrao = read_xls("estrutura padrão.xls")
  #teste = reverte.lista.pais.ano (estrutura.padrao)
  #write.csv(teste, file = "teste.csv", row.names = FALSE)
  
}


#####
############  função filtra valores para uma tabela ano-pais mais restrita
#####


#


filtra.valores <- function(dados.filtrados, dados.fonte, eh.numerico)
  #   recupera os valores de uma tabela ordenada ano-pais mais ampla, para
  #   colocá-los em uma tabela ano-país mais restrita (em especial, das tabelas
  #    de governos em geral para as de governos de minoria, e de governos de 
  #     minoria para as tabelas-verdade)
  #               - a saída (dados.filtrados) é um dataframe com três colunas: país (cod. inernet),
  #                  ano (4 digitos) e o valor do dado recuperado em questão 
  #               - a entrada (dados.fonte) é um dataframe com três colunas: país (cod. inernet), 
  #                  ano (4 digitos) e o valor do dado no arquivo original 
  #               - eh.numerico é um código que indica se a coluna de resultado filtrado
  #                  deve ser convertida em valor numérico (eh.numerico = 1) ou não (eh.numerico = 0)

{  
for (k in 1:nrow(dados.filtrados) )
{
  aux.ano.pais.filtro <- as.data.frame (
    dados.fonte   [ dados.fonte$CTR == dados.filtrados$CTR [k] &
                                 as.numeric(dados.fonte$YR) == as.numeric(dados.filtrados$YR [k]), ]
  )

  dados.filtrados$RESULTADO [k]   <-  aux.ano.pais.filtro [,3]
  
  if (eh.numerico == 1)
  {
  dados.filtrados$RESULTADO [k]   <-  as.numeric(dados.filtrados$RESULTADO [k])
  }
}

return (dados.filtrados)
}  # end function



###  procedure section (lembrança do cobol)

###################################################################################
########################
###########                   preparação geral dos dados provenientes do V-Dem (todos)
########################
###################################################################################

############################################################################################
# seta parametros gerais
############################################################################################

performance.duas.variaveis <- TRUE

############################################################################################
# carrega toda a base
############################################################################################

modelo.VDem = readRDS("V-Dem-CY-Full+Others-v12.rds")
# filtra por países
#  aqui não foram retirados GT e NI, porque os dados podem ser
#   necessários para a média latinoamericana
modelo.VDem.por.pais = modelo.VDem [modelo.VDem$country_text_id %in% 
                                      c ("ARG", "BOL", "BRA", "CHL", "COL", "CRI", "DOM", "SLV",
                                         "GTM", "HND", "MEX", "NIC", "PAN", "PRY", "PER", "URY", "VEN"), ]
# filtra por ano
#  inicio e fim deixados com uma folga de um ano, para eventual necessidade de 
#   apurar variações interanuais nos dois extremos do intervalo
data.inicio = 1977
data.fim = 2019

modelo.VDem.por.pais.data = modelo.VDem.por.pais [((modelo.VDem.por.pais$year > (data.inicio - 1)) &
                                                     (modelo.VDem.por.pais$year < (data.fim + 1))), ] 

# insere column id pelo código uniforme de pais com dois digitos
colnames(modelo.VDem.por.pais.data)[colnames(modelo.VDem.por.pais.data) == 'country_id'] = 'cod_pais'

modelo.VDem.por.pais.data$cod_pais = as.character(modelo.VDem.por.pais.data$cod_pais)

for (k in 1:nrow(modelo.VDem.por.pais.data))
{
  if (modelo.VDem.por.pais.data$country_text_id  [k] ==     "ARG" ) 
  { modelo.VDem.por.pais.data$cod_pais  [k]  = "AR"}
  
  if (modelo.VDem.por.pais.data$country_text_id  [k] ==     "BOL" ) 
  { modelo.VDem.por.pais.data$cod_pais  [k]  = "BO"}
  
  if (modelo.VDem.por.pais.data$country_text_id  [k] ==     "BRA" ) 
  { modelo.VDem.por.pais.data$cod_pais  [k]  = "BR"}
  
  if (modelo.VDem.por.pais.data$country_text_id  [k] ==     "CHL" ) 
  { modelo.VDem.por.pais.data$cod_pais  [k]  = "CL"}
  
  if (modelo.VDem.por.pais.data$country_text_id  [k] ==     "COL" ) 
  { modelo.VDem.por.pais.data$cod_pais  [k]  = "CO"}
  
  if (modelo.VDem.por.pais.data$country_text_id  [k] ==     "CRI" ) 
  { modelo.VDem.por.pais.data$cod_pais  [k]  = "CR"}
  
  if (modelo.VDem.por.pais.data$country_text_id  [k] ==     "DOM" ) 
  { modelo.VDem.por.pais.data$cod_pais  [k]  = "DR"}
  
  if (modelo.VDem.por.pais.data$country_text_id  [k] ==     "SLV" ) 
  { modelo.VDem.por.pais.data$cod_pais  [k]  = "SV"}
  
  if (modelo.VDem.por.pais.data$country_text_id  [k] ==     "GTM" ) 
  { modelo.VDem.por.pais.data$cod_pais  [k]  = "GT"}
  
  if (modelo.VDem.por.pais.data$country_text_id  [k] ==     "HND" ) 
  { modelo.VDem.por.pais.data$cod_pais  [k]  = "HN"}
  
  if (modelo.VDem.por.pais.data$country_text_id   [k]  ==  "MEX" ) 
  { modelo.VDem.por.pais.data$cod_pais  [k]   = "MX"}
  
  if (modelo.VDem.por.pais.data$country_text_id  [k] ==  "NIC" ) 
  { modelo.VDem.por.pais.data$cod_pais  [k]  = "NI"}
  
  if (modelo.VDem.por.pais.data$country_text_id  [k] == "PAN" ) 
  { modelo.VDem.por.pais.data$cod_pais  [k]  = "PA"}
  
  if (modelo.VDem.por.pais.data$country_text_id  [k] ==   "PRY" ) 
  { modelo.VDem.por.pais.data$cod_pais  [k]  = "PY"}
  
  if (modelo.VDem.por.pais.data$country_text_id  [k] == "PER" ) 
  { modelo.VDem.por.pais.data$cod_pais  [k]  = "PE"}
  
  if (modelo.VDem.por.pais.data$country_text_id  [k] ==     "URY" ) 
  { modelo.VDem.por.pais.data$cod_pais  [k]  = "UY"}
  
  if (modelo.VDem.por.pais.data$country_text_id  [k] ==     "VEN" ) 
  { modelo.VDem.por.pais.data$cod_pais  [k]  = "VE"}
  
}
############################################################################################
# indices de democracia
############################################################################################
# 
#           carrega os dados
carga.democracia.PolityV = read_xls("Polity V.xls", sheet = "carga")
carga.democracia.FreedomHouse = read_xls("Freedom House.xls", sheet = "carga")
#           combina os dois índices
indice.democracia.combinado = carga.democracia.PolityV
for (i in 2:nrow(indice.democracia.combinado))
{
  for (j in 2:ncol(indice.democracia.combinado))
  {
    if ( is.na(carga.democracia.PolityV [i,j]) | is.na(carga.democracia.FreedomHouse[i,j]))
    {indice.democracia.combinado [i,j] = NA}
    else
    {indice.democracia.combinado [i,j] = 1}
  }
}



# para gerar arquivo linear pais.ano em auxilio à montagem da base de gabinetes
#indice.democracia.auxiliar = reverte.lista.pais.ano (indice.democracia.combinado)
#write.table(indice.democracia.auxiliar, file = "democracia.csv", row.names = FALSE)


###################################################################################
########################
###########                   Monta indicador good policy performance
########################
###################################################################################

############################################################################################
# carrega os arquivos de variaveis econômicas
# a planilha lida contém o valor crisp fuzzy da associação entre o  valor da variável no 
# ano-país e a média ajustada da América Latina (os valores "NA" precisam
# ser traduzidos para NA na linguagem de máquina do R)
############################################################################################

# GDP
carga.GDP <- read_xls("GDP v2.0.xls", sheet = "carga")
carga.GDP [carga.GDP == "NA"] <- NA 

# inflação
carga.inflation <- read_xls("Inflation v2.0.xls", sheet = "carga")
carga.inflation [carga.inflation == "NA"] <- NA 

# Desemprego
carga.unemployment <- read_xls("Unemployment v2.0.xls", sheet = "carga")
carga.unemployment [carga.unemployment == "NA"] <- NA 

# Desigualdade
carga.inequality <- read_xls("Inequality from household consumption v2.0.xls", sheet = "carga")
carga.inequality [carga.inequality == "NA"] <- NA 

#
############################################################################################
# monta o indicador fuzzy combinado, no formato original cross-tab
############################################################################################

# cria o arquivo de saida, zerado com NA
carga.policy.performance <- carga.GDP
carga.policy.performance [ ! is.na(carga.policy.performance) ] <- NA
carga.policy.performance$YR <- carga.GDP$YR

if (performance.duas.variaveis) 
{
  # preenche o arquivo de saida  (apenas duas variáveis, GDP e inequality)
for ( k in 2:ncol(carga.GDP))
{
  for ( j in 1:nrow(carga.GDP))
  {
    if ( (! is.na (carga.GDP [j,k])) &
         (! is.na (carga.inequality [j,k]))
        )
    {
      
      num.var.positivas <- (as.numeric(carga.GDP [j,k]) 
                            + as.numeric(carga.inequality [j,k])
      )
      
      #    carrega o valor fuzzy do resultado em função do número de
      #    variaveis econômicas mehores que a média (fuzzy 1)
      if (num.var.positivas == 2)
      { carga.policy.performance [j,k] <- 1}
      else
      {
### explorar - muda o valor fuzzy da performance de 0,66 para 0,33 e vice-versa
#        
        if (num.var.positivas == 1)
          { carga.policy.performance [j,k] <- 0.66}  # <-- aqui
        else
            { carga.policy.performance [j,k] <- 0} 
#          }
#        }
      }
    }
    
  }  # endfor linhas (ano)
}  # endfor colunas (pais)
} else
#else
{
# preenche o arquivo de saida  (4 variáveis: GDP , inequality, inflação e desemprego)
for ( k in 2:ncol(carga.GDP))
{
  for ( j in 1:nrow(carga.GDP))
  {
    if ( (! is.na (carga.GDP [j,k])) &
         (! is.na (carga.inflation [j,k])) &
         (! is.na (carga.inequality [j,k])) &
         (! is.na (carga.unemployment [j,k])) 
    )
    {
      
      num.var.positivas <- (as.numeric(carga.GDP [j,k]) 
                            + as.numeric(carga.inflation [j,k]) 
                            + as.numeric(carga.inequality [j,k])
                            + as.numeric(carga.unemployment [j,k])
      )
      
      #    carrega o valor fuzzy do resultado em função do número de
      #    variaveis econômicas mehores que a média (fuzzy 1)
      if (num.var.positivas == 4)
      { carga.policy.performance [j,k] <- 1}
      else
      {
        if (num.var.positivas == 3)
        { carga.policy.performance [j,k] <- 0.75}
        else
          {
          if (num.var.positivas == 2)
          { carga.policy.performance [j,k] <- 0.25}
          else
          {
        { carga.policy.performance [j,k] <- 0} 
                 }
                }
      }
    }
    
  }  # endfor linhas (ano)
}  # endfor colunas (pais)
} # end-else



############################################################################################
# abre o indicador fuzzy combinado no formato ano-pais das bases de governos minoritários
############################################################################################

add.policy.performance <-  list (CTR = "CT", YR = 1900, ind.performance = 2)
ind.policy.performance <-  list (CTR = "CT", YR = 1900, ind.performance = 2)
ind.policy.performance <- data.frame (ind.policy.performance)
ind.primeiro.registro.gravado <-  0

for ( k in 2:ncol(carga.policy.performance))
{
  for ( j in 1:nrow(carga.policy.performance))
  {
    if (ind.primeiro.registro.gravado  == 0)
    {
      ind.policy.performance$CTR [j] <- colnames(carga.policy.performance [k])
      ind.policy.performance$YR [j] <- carga.policy.performance [j,1]
      ind.policy.performance$ind.performance [j] <- carga.policy.performance [j,k]
      
      ind.primeiro.registro.gravado <- 1
    }
    else
    {
      add.policy.performance$CTR <- colnames(carga.policy.performance [k])
      add.policy.performance$YR  <- carga.policy.performance [j,1]
      add.policy.performance$ind.performance  <- carga.policy.performance [j,k]    
      ind.policy.performance <- rbind (ind.policy.performance, add.policy.performance)
    }
  }
}
ind.policy.performance$YR = as.numeric(ind.policy.performance$YR)
ind.policy.performance$ind.performance = as.numeric(ind.policy.performance$ind.performance)

# end versão tese2








###################################################################################
########################
###########                   identificação de governos de minoria
########################
###################################################################################

#################################################################
########################### procedimento principal
#################################################################


gabinetes.e.parlamentos = read_excel("gabinetes.e.parlamentos.xls", col_names = TRUE)
# se for um csv
# parm.lista.a.conferir = read.csv("gabinetes.e.parlamentos.csv")

#inicializa variaveis do loop
primeiro.registro.saida.basica <- 1
pais.corrente <- as.character(gabinetes.e.parlamentos$CTRY [1])
ano.corrente <- as.numeric(gabinetes.e.parlamentos$YR [1])
percentual.lower.house <- 0
percentual.upper.house <- 0
num.partidos.gabinete <- 0


for (k in 1:nrow(gabinetes.e.parlamentos))
{  # begin for
  # enquanto permanecer no mesmo país/ano, soma percentuais de lower e upper house ano a ano
  
  
  if (as.character(gabinetes.e.parlamentos$CTRY [k]) == pais.corrente)
  { 
    
    if (as.numeric(gabinetes.e.parlamentos$YR [k]) == ano.corrente)
      # acumula no mesmo ano/país, para os partidos que têm representação no gabinete
    {
      if ((gabinetes.e.parlamentos$CABINET_SHARE [k] > 0) &  (gabinetes.e.parlamentos$PARTY [k] != "no party"))
      {
        percentual.lower.house = percentual.lower.house + gabinetes.e.parlamentos$SEAT_SHARE_LOW_CHAMBER [k]
        num.partidos.gabinete <- num.partidos.gabinete + 1
        
        if (! is.na (gabinetes.e.parlamentos$SEAT_SHARE_HIGH_CHAMBER [k]))
        {percentual.upper.house = percentual.upper.house + gabinetes.e.parlamentos$SEAT_SHARE_HIGH_CHAMBER [k] }
        else
        {percentual.upper.house = NA }    
      }
    }
    
    else
      # mudou o ano
    {
      # mudou o ano no mesmo pais: carrega os totais acumulados no pais/ano anterior
      if (primeiro.registro.saida.basica == 1)  # primeiro registro do data.frame de saida
      {
        
        # cria data-frame de saída com ano-pais, % da camara e % do senado
        saida.basica <- data.frame (CTR = gabinetes.e.parlamentos$CTRY [k-1],
                                    YR = gabinetes.e.parlamentos$YR [k-1], 
                                    PCT.LOW = percentual.lower.house, 
                                    PCT.HIGH =percentual.upper.house,
                                    NUM.PARTIDOS.GABINETE = num.partidos.gabinete)
        
        primeiro.registro.saida.basica <- 0
        percentual.lower.house <- 0
        percentual.upper.house <- 0
      }
      else  # registros seguintes do dataframe de saida
        
      {
        novo.ano.pais <- c (gabinetes.e.parlamentos$CTRY [k-1], 
                            gabinetes.e.parlamentos$YR [k-1],
                            percentual.lower.house,
                            percentual.upper.house,
                            num.partidos.gabinete)
        saida.basica <- rbind (saida.basica, novo.ano.pais)
        # mudou o ano no mesmo pais: atualiza o valor de ano corrente
        
      }  
      
      # mudou o ano no mesmo pais: atualiza o valor de ano corrente
      ano.corrente <- gabinetes.e.parlamentos$YR [k]
      
      #  mudou o ano no mesmo pais: reinicia o valor acumulado para o ano corrente
      
      if ((gabinetes.e.parlamentos$CABINET_SHARE [k] > 0) &  (gabinetes.e.parlamentos$PARTY [k] != "no party"))
      {
        percentual.lower.house = gabinetes.e.parlamentos$SEAT_SHARE_LOW_CHAMBER [k]
        num.partidos.gabinete <- 1
        
        if (! is.na (gabinetes.e.parlamentos$SEAT_SHARE_HIGH_CHAMBER [k]))
        {percentual.upper.house = gabinetes.e.parlamentos$SEAT_SHARE_HIGH_CHAMBER [k] }
        else
        {percentual.upper.house = NA }    
      }
      else
      {
        percentual.lower.house = 0
        num.partidos.gabinete <- 0
        
        if (! is.na (gabinetes.e.parlamentos$SEAT_SHARE_HIGH_CHAMBER [k]))
        {percentual.upper.house = 0 }
        else
        {percentual.upper.house = NA }    
      }
      
      
    }
    
  }
  #  endif no mesmo pais
  else
    # # mudou o pais
  {
    # mudou o pais: carrega os totais acumulados no pais/ano anterior 
    #  (desnecessário prever o primeiro registro do dataframe de saída, porque o primeiro
    #   país sempre terá tido uma somatoria de alguns anos)
    novo.ano.pais <- c (gabinetes.e.parlamentos$CTRY [k-1], 
                        gabinetes.e.parlamentos$YR [k-1],
                        percentual.lower.house,
                        percentual.upper.house,
                        num.partidos.gabinete)
    saida.basica <- rbind (saida.basica, novo.ano.pais)
    
    # mudou o pais: atualiza o valor de ano e pais correntes
    pais.corrente <- gabinetes.e.parlamentos$CTRY [k]
    ano.corrente <- gabinetes.e.parlamentos$YR [k]
    
    # mudou  o pais: reinicia o valor acumulado para o novo ano/pais corrente
    
    if ((gabinetes.e.parlamentos$CABINET_SHARE [k] > 0) &  (gabinetes.e.parlamentos$PARTY [k] != "no party")) 
    {
      percentual.lower.house = gabinetes.e.parlamentos$SEAT_SHARE_LOW_CHAMBER [k]
      num.partidos.gabinete <- 1
      
      if (! is.na (gabinetes.e.parlamentos$SEAT_SHARE_HIGH_CHAMBER [k]))
      { percentual.upper.house = gabinetes.e.parlamentos$SEAT_SHARE_HIGH_CHAMBER [k] }
      else
      {percentual.upper.house = NA }
    }
    else
    {
      percentual.lower.house = 0
      num.partidos.gabinete <- 1
      
      if (! is.na (gabinetes.e.parlamentos$SEAT_SHARE_HIGH_CHAMBER [k]))
      {percentual.upper.house = 0 }
      else
      {percentual.upper.house = NA }
    }
    
    
    
  }  # end-else de mudança de país
  
  
}  #end for

#  último registro (saiu do loop)

novo.ano.pais <- c (gabinetes.e.parlamentos$CTRY [k], 
                    gabinetes.e.parlamentos$YR [k],
                    percentual.lower.house,
                    percentual.upper.house,
                    num.partidos.gabinete)
saida.basica <- rbind (saida.basica, novo.ano.pais)


# indicadores basicos
saida.basica$ind.minority.lower <- 0  # indicador de minoria na camara baixa (< 50%)
saida.basica$ind.minority.upper <- 0  # indicador de minoria na camara alta (< 50%)

saida.basica$ind.threshold45pct.lower <- 0  # indicador de limiar de 45 % da bancada 
#                                       na camara baixa (45% < threshold < 50%)
saida.basica$ind.threshold45pct.upper <- 0  # indicador de limiar de 45 % da bancada 
#                                       na camara alta (45% < threshold < 50%)
#                                       nas duas camaras  (45% < threshold < 50%)
saida.basica$ind.threshold40pct.lower <- 0  # indicador de limiar de 40 % da bancada 
#                                       na camara baixa (40% < threshold < 50%)
saida.basica$ind.threshold40pct.upper <- 0  # indicador de limiar de 45 % da bancada 
#                                       na camara alta (40% < threshold < 50%)

#indicadores compostos
saida.basica$ind.minority <- 0        #  indicador de minoria analítico (minoria 
#                                       unicameral ou de qualquer das camaras bicamerais
saida.basica$ind.minority.unicameral <- 0  #  indicador de minoria unicameral
saida.basica$ind.minority.only.lower <- 0  #  indicador de minoria apenas na câmara 
#                                             baixa em parlamentos bicamerais
saida.basica$ind.minority.only.upper <- 0  #  indicador de minoria apenas na câmara 
#                                             alta em parlamentos bicamerais
saida.basica$ind.minority.both <- 0  #  indicador de minoria em ambas as câmaras 
#                                             em parlamentos bicamerais

for (k in 1:nrow(saida.basica))
{
  if (saida.basica$PCT.LOW [k] < 0.5)
  {
    saida.basica$ind.minority.lower [k] <- 1
    
    if (saida.basica$PCT.LOW [k] > 0.4)
    {saida.basica$ind.threshold40pct.lower [k] <- 1 }
    
    if (saida.basica$PCT.LOW [k] > 0.45)
    {saida.basica$ind.threshold45pct.lower [k] <- 1 }
  }
  
  if (! is.na(saida.basica$PCT.HIGH [k]))
  {
    #  trata casos bicamerais    
    if (saida.basica$PCT.HIGH [k] < 0.5)
    {
      {saida.basica$ind.minority.upper [k] <- 1}
      
      if (saida.basica$PCT.HIGH [k] > 0.4)
      {saida.basica$ind.threshold40pct.upper [k] <- 1 }
      
      if (saida.basica$PCT.HIGH [k] > 0.45)
      {saida.basica$ind.threshold45pct.upper [k] <- 1 }
    }
  }
  else 
  {
    saida.basica$ind.minority.upper [k] <- NA
    saida.basica$ind.threshold40pct.upper [k] <- NA
    saida.basica$ind.threshold45pct.upper [k] <- NA
  }
  
  if (is.na(saida.basica$ind.minority.upper [k]))
    #    casos unicamerais    
  {
    if (saida.basica$ind.minority.lower [k] == 1)
      saida.basica$ind.minority.unicameral [k] <- 1
  }
  else
  {
    if (saida.basica$ind.minority.lower [k] == 1)
    {
      if (saida.basica$ind.minority.upper [k] == 1)
      {saida.basica$ind.minority.both [k] <- 1} 
      else
      {saida.basica$ind.minority.only.lower [k] <- 1}
    }
    else
    {
      if (saida.basica$ind.minority.upper [k] == 1)
      {saida.basica$ind.minority.only.upper [k] <- 1} 
    }
  }
  # indicador de qualquer tipo de minoria (definição analítica)
  if  ( (saida.basica$ind.minority.unicameral [k] == 1)  | 
        (saida.basica$ind.minority.only.lower [k] ==1) |
        (saida.basica$ind.minority.only.upper [k] ==1) |
        (saida.basica$ind.minority.both [k] ==1) )
  {saida.basica$ind.minority [k] <- 1}
  
  # indicadores equivalentes para minorias de 40 e 45 pct (definição analítica,
  #    de percentagens entre 40/45 e 50 pct em ambas as câmaras)
  #  (esse indicador unificado de threshold, pela lógica analítica, é igual a 1
  #   tanto se a câmara tem entre 40/45 e 50 quanto se a câmara tem mais de 50%;
  #   nesse sentido, difere dos outros indicadores de threshold que só se 
  #   aplicam quando ocorre uma situação de minoria)
  #
  #  casos unicamerais
  saida.basica$ind.threshold40pct [k] <- 0
  saida.basica$ind.threshold45pct [k] <- 0
  
  if  ( is.na (saida.basica$PCT.HIGH [k]) )
  { 
    if ( (saida.basica$ind.threshold40pct.lower [k] == 1) |
         (saida.basica$ind.minority.unicameral [k] == 0) )
    {saida.basica$ind.threshold40pct [k] <- 1}
    if ( (saida.basica$ind.threshold45pct.lower [k] == 1) |
         (saida.basica$ind.minority.unicameral [k] == 0) )
    {saida.basica$ind.threshold45pct [k] <- 1}
    
  }
  else
    #  casos bicamerais
  {
    if ( 
         ((saida.basica$ind.threshold40pct.lower [k] == 1) |
          (saida.basica$ind.minority.lower [k] == 0) )
              &
         ((saida.basica$ind.threshold40pct.upper [k] == 1)|
          (saida.basica$ind.minority.upper [k] == 0) )  
        )
    {saida.basica$ind.threshold40pct [k] <- 1}
    
    if (
         ( (saida.basica$ind.threshold45pct.lower [k] == 1)|
           (saida.basica$ind.minority.lower [k] == 0) ) 
           &
          ( (saida.basica$ind.threshold45pct.upper [k] == 1)|
            (saida.basica$ind.minority.upper [k] == 0) )  
         )
    {saida.basica$ind.threshold45pct [k] <- 1}
    
  }     
  
}# END FOR



############################################################################################
# explora governos non-partisan
############################################################################################
ind.primeiro.registro.gravado <- 1

saida.non.partisan <- data.frame (CTR = "CT", YR = 1900, NON_PARTY_SHARE = 0, 
                                  ind.minority = 0, ind.non.partisan = 0, 
                                  ind.minority.and.non.partisan = 0)
aux.non.partisan <- data.frame  (CTR = "CT", YR = 1901, NON_PARTY_SHARE = 1, 
                                  ind.minority = 1, ind.non.partisan = 1, 
                                 ind.minority.and.non.partisan =1)



for (i in 1:nrow(gabinetes.e.parlamentos))
{
  if ( (gabinetes.e.parlamentos$PARTY [i] == "no party") &
        (gabinetes.e.parlamentos$CABINET_SHARE [i] > 0)  )
  {
    if (ind.primeiro.registro.gravado == 1)
    {
      saida.non.partisan$CTR <- gabinetes.e.parlamentos$CTRY [i]
      saida.non.partisan$YR <- gabinetes.e.parlamentos$YR [i]
      saida.non.partisan$NON_PARTY_SHARE <- gabinetes.e.parlamentos$CABINET_SHARE [i]
      
      if (saida.non.partisan$NON_PARTY_SHARE > 0.5)
      {saida.non.partisan$ind.non.partisan = 1}
      else
      {saida.non.partisan$ind.non.partisan = 0}
      
      for (j in 1:nrow(saida.basica))
      { if ((saida.basica$CTR [j] == gabinetes.e.parlamentos$CTRY [i]) &
            (saida.basica$YR [j] == gabinetes.e.parlamentos$YR [i]))
        { 
           saida.non.partisan$ind.minority <- saida.basica$ind.minority [j] 
           
           if ((saida.non.partisan$ind.non.partisan == 1) &
               (saida.non.partisan$ind.minority == 1))
           {saida.non.partisan$ind.minority.and.non.partisan <- 1}
          else 
          {saida.non.partisan$ind.minority.and.non.partisan <- 0 }
        
        }
      }
      ind.primeiro.registro.gravado <- 0    
    }
    else
    {
      aux.non.partisan$CTR <- gabinetes.e.parlamentos$CTRY [i]
      aux.non.partisan$YR <- gabinetes.e.parlamentos$YR [i]
      aux.non.partisan$NON_PARTY_SHARE <- gabinetes.e.parlamentos$CABINET_SHARE [i]
      
      if (aux.non.partisan$NON_PARTY_SHARE > 0.5)
      {aux.non.partisan$ind.non.partisan = 1}
      else
      {aux.non.partisan$ind.non.partisan = 0}
      
      
      for (j in 1:nrow(saida.basica))
      { if ((saida.basica$CTR [j] == gabinetes.e.parlamentos$CTRY [i]) &
            (saida.basica$YR [j] == gabinetes.e.parlamentos$YR [i]))
      { 
      aux.non.partisan$ind.minority <- saida.basica$ind.minority [j] 
      if ((aux.non.partisan$ind.non.partisan == 1) &
          (aux.non.partisan$ind.minority == 1))
      {aux.non.partisan$ind.minority.and.non.partisan <- 1}
      else 
      {aux.non.partisan$ind.minority.and.non.partisan <- 0 }
      }
      } 
      
       saida.non.partisan <- rbind (saida.non.partisan, aux.non.partisan)      
    } #end-else
  }
} # end-for

## gera arquivo específico de gabinetes não-partidários em todos os anos-país 
## para outras pesquisas



ministros.non.partisan <- gabinetes.e.parlamentos[, c("CTRY", "YR", "PARTY", "CABINET_SHARE")]
ministros.non.partisan <- subset (ministros.non.partisan, PARTY == "no party")


write_xlsx(ministros.non.partisan,
  path = "ministros.non.partisan.xlsx",
  col_names = TRUE,
  #  format_headers = TRUE,
  # use_zip64 = TRUE
)



############################################################################################
# explora governos single-party vs. coalition
############################################################################################

saida.basica$ind.single.party <- saida.basica$ind.minority
saida.basica$ind.single.party <- 0        #  indicador de se o governo é single-party 
                                          # (governos em que não há nenhum partido no 
                                          #  gabinete recebem 0, como em coalizões )
for ( i in 1:nrow (saida.basica))
{
  if (saida.basica$NUM.PARTIDOS.GABINETE [i] == 1 )
  {saida.basica$ind.single.party [i] <- 1}
}

aux.impr.single.party <- data.frame(saida.basica$CTR,saida.basica$YR,
                                    saida.basica$ind.single.party)
colnames(aux.impr.single.party) <- c( "CTR", "YR", "SINGLE_PARTY")

#  esse indicador vai ser convertido numa condição crisp, diretamente
#  (já está codificado em 0 e 1)

############################################################################################
# gera tabelas de saida
############################################################################################
#  tabelas de saída
# totais: geral / minoria só camara bicameral / minoria só senado bicameral / 
#              minoria ambos bicameral / minoria unicameral 
# analítico: minorias (marcação de cada câmara)

relatorio.analitico <- saida.basica [saida.basica$ind.minority == 1,]
relatorio.analitico <- relatorio.analitico[c(1, 2, 3, 4, 5, 12)]
relatorio.analitico$PCT.LOW <- as.numeric (relatorio.analitico$PCT.LOW)*100
relatorio.analitico$PCT.HIGH <- as.numeric (relatorio.analitico$PCT.HIGH)*100
  # comandos aparentemente lógicos
  # mas que geram distorções na formatação de saída:
  #   relatorio.analitico$YR <- as.numeric (relatorio.analitico$YR)*100
  #   relatorio.analitico$PCT.LOW <- format(relatorio.analitico$PCT.LOW, decimal.mark = ",", digits = 3)
  #   relatorio.analitico$PCT.HIGH <- format(relatorio.analitico$PCT.HIGH, decimal.mark = ",", digits = 3)

total0 <- c ("Governments in country/years", NA)
total1 <- c ("Total number of governments", nrow(saida.basica))
total2 <- c ("Total number of minority governments", sum(saida.basica$ind.minority))
total3 <- c ("Total numer of minority situations only in the bicameral lower house", sum(saida.basica$ind.minority.only.lower))
total4 <- c ("Total number of minority situations only in the bicameral upper house", sum(saida.basica$ind.minority.only.upper))
total5 <- c ("Total number of minority situations in both bicameral houses", sum(saida.basica$ind.minority.both))
total6 <- c ("Total number of minority situations in unicameral parliaments", sum(saida.basica$ind.minority.unicameral))

# trata os legislative support thresholds 40 e 45%
total7 <- c ("Legislative support thresholds", NA)
total.over.40 <- sum(saida.basica$ind.threshold40pct.lower, na.rm = TRUE) + sum(saida.basica$ind.threshold40pct.upper, na.rm = TRUE)
total.over.45 <- sum(saida.basica$ind.threshold45pct.lower, na.rm = TRUE) + sum(saida.basica$ind.threshold45pct.upper, na.rm = TRUE)
total.between.40.45 <- total.over.40 - total.over.45
# soma das câmaras que têm minoria (tomadas individualmente) - o número de situações bicamerais precisa  
#  ser computado duas vezes, pois cada situação representa duas câmaras em minoria
total.minority.any.chamber <- as.numeric(total3[2]) + as.numeric(total4[2]) + as.numeric(total6[2]) + (2*as.numeric(total5[2])) 
pct.under.40 <- (total.minority.any.chamber - total.over.40) / total.minority.any.chamber * 100
pct.under.40 <- format(pct.under.40, decimal.mark = ",", digits = 3)
pct.between.40.45 <- total.between.40.45 / total.minority.any.chamber * 100
pct.between.40.45 <- format(pct.between.40.45, decimal.mark = ",", digits = 3)
pct.between.45.50 <- total.over.45 / total.minority.any.chamber * 100
pct.between.45.50 <- format(pct.between.45.50, decimal.mark = ",", digits = 3)


total8 <- c ("Total number of minority governments below 40% in any chamber", (total.minority.any.chamber - total.over.40)) 
total9 <- c (" as a share of minority governments in any chamber (%)", pct.under.40)
total10 <- c ("Total number of minority governments between 40% and 45% in any chamber", total.between.40.45)
total11 <- c (" as a share of minority governments in any chamber (%)", pct.between.40.45)
total12 <- c ("Total number of minority governments between 45% and 50% in any chamber", total.over.45)
total13 <- c (" as a share of minority governments in any chamber (%)", pct.between.45.50)


final.summary <- rbind (total0, total1, total2, total3, total4, total5, total6, 
                        total7, total8, total9, total10, total11, total12, total13 )
final.summary <- as.data.frame (final.summary)

############################################################################################
#  tabelas de ministros não-partidarios
# totais: geral / não-partidarios sobre geral / não-partidarios sobre minoritarios 
average.non.partisan.share <- mean(saida.non.partisan$NON_PARTY_SHARE)

total0_np <- c ("Governments in country/years", NA)
total1_np <- c ("Total number of governments", nrow(saida.basica))
total2_np <- c ("Total number of governments with non-partisan ministers", nrow(saida.non.partisan))
total3_np <- c ("Total number of minority governments", sum(saida.basica$ind.minority))
total4_np <- c ("Total numer of minority governments with non-partisan ministers", sum(saida.non.partisan$ind.minority))
total5_np <- c ("Total number of governments with a majority of non-partisan ministers", sum(saida.non.partisan$ind.non.partisan))
total6_np <- c ("Total number of minority governments with a majority of non-partisan ministers", sum(saida.non.partisan$ind.minority.and.non.partisan))
total7_np <- c ("Average share of non-partisan ministers in all cabinets", average.non.partisan.share)

final.summary.non.partisan <- rbind (total0_np, total1_np, total2_np, total3_np, total4_np, total5_np, total6_np, total7_np)
final.summary.non.partisan <- as.data.frame (final.summary.non.partisan)

###  gera histograma para non-partisan share of cabinets


non.partisan.stats <- saida.non.partisan |>
  summarize(mean_price = mean(saida.non.partisan$NON_PARTY_SHARE))


library(ggplot2)
library(readr)
library(dplyr)
non.partisan.histogram <- ggplot(data = saida.non.partisan, aes(x = NON_PARTY_SHARE)) +
  geom_histogram() +
  geom_vline(aes(xintercept = average.non.partisan.share), non.partisan.stats, color = "red", linewidth = 1) +
  labs(x="Share of non-partisan ministers in the cabinet", y = "Number of cabinets (in country-years")
# Print plots to a pdf file
#pdf("Non_partisan_histogram.pdf")  <== caso fosse gravar um arquivo PDF
jpeg("Non_partisan_histogram.jpg")
print(non.partisan.histogram)     # Plot 1 --> in the first page of PDF
dev.off()


#Subtotais por país (minoria/total)


saida.basica$num.total.governos <- 1
subtotais.pais <- calcula.subtotais (saida.basica$CTR, saida.basica$ind.minority,
                                     saida.basica$ind.threshold40pct, saida.basica$ind.threshold45pct,
                                     saida.basica$num.total.governos, NA)
subtotais.pais <- subtotais.pais [,1:5]

colnames(subtotais.pais) <- c('Country','Minority governments - absolute numbers',
                              'Minority above 40pct - absolute numbers', 'Minority above 45pct - absolute numbers',
                              'Total number of Governments')

subtotais.pais$percent.minority.govts <- as.numeric(subtotais.pais [,2]) / as.numeric(subtotais.pais [,5]) * 100
subtotais.pais$percent.minority.govts <- format(subtotais.pais$percent.minority.govts, decimal.mark = ",", digits = 3)

#Subtotais por ano / gráfico (número absoluto)
#(empilhado 0-40%, 40-45%, 45-50%)


total.ordenado.por.ano <- saida.basica[order(saida.basica$YR),]
total.ordenado.por.ano <- total.ordenado.por.ano[total.ordenado.por.ano$ind.minority == 1,]


subtotais.ano <- calcula.subtotais (total.ordenado.por.ano$YR, total.ordenado.por.ano$ind.minority,
                                    total.ordenado.por.ano$ind.threshold40pct, total.ordenado.por.ano$ind.threshold45pct,
                                    NA, NA)

subtotais.ano <- subtotais.ano [,1:4]

aux.totais.governo <- saida.basica[order(saida.basica$YR),]
aux.totais.governo <- 
  calcula.subtotais (aux.totais.governo$YR, aux.totais.governo$num.total.governos,
                     NA, NA, NA, NA)

subtotais.ano$num.total.governos <- aux.totais.governo [,2]

colnames(subtotais.ano) <- c('Year','Minority governments - absolute numbers',
                             'Minority above 40pct - absolute numbers', 
                             'Minority above 45pct - absolute numbers',
                             'Total number of Governments')


###################################################################################
########################
###########                   associa governos minoritários a indicador de policy performance
########################
###################################################################################


############################################################################################
#  associando resultados ao proprio ano do governo
############################################################################################

for (k in 1:nrow(relatorio.analitico) )
{
  aux.ano.pais.performance <- as.data.frame (
                                  ind.policy.performance   [ ind.policy.performance$CTR == relatorio.analitico$CTR [k] &
                                  ind.policy.performance$YR == as.numeric(relatorio.analitico$YR [k]), ]
                                            )
 relatorio.analitico$policy.performance [k]   <-  as.numeric(aux.ano.pais.performance [,3])

 }


############################################################################################
#  associando resultados ao ano seguinte ao do governo (lagged) 
############################################################################################

for (k in 1:nrow(relatorio.analitico) )
{
if (relatorio.analitico$YR [k] < 2018)
   #  descarta a performance lagged de 2018, último ano para o qual há dados de resultado na base 
    {
      aux.ano.pais.performance <- as.data.frame (
    ind.policy.performance   [ ind.policy.performance$CTR == relatorio.analitico$CTR [k] &
                                 ind.policy.performance$YR == (as.numeric(relatorio.analitico$YR [k]) + 1), ]
  )
  relatorio.analitico$policy.performance.lagged [k]   <-  as.numeric(aux.ano.pais.performance [,3])
  }
}



#Subtotais de performance por país (boa/ruim)

aux.subtotais.performance <- subset(relatorio.analitico, select = c(CTR,policy.performance, policy.performance.lagged) )
aux.subtotais.performance$positivo <- 0
aux.subtotais.performance$negativo <- 0
aux.subtotais.performance$positivo.lagged <- 0
aux.subtotais.performance$negativo.lagged <- 0

# begin versão tese2
for (k in 1:nrow(aux.subtotais.performance))
{
if (! is.na (aux.subtotais.performance$policy.performance [k]) )
{
  if (aux.subtotais.performance$policy.performance [k] > 0.5)
  {aux.subtotais.performance$positivo [k] <- 1}
  else
  {aux.subtotais.performance$negativo [k] <- 1}
}
  if (! is.na (aux.subtotais.performance$policy.performance.lagged [k]))
  {
    if (aux.subtotais.performance$policy.performance.lagged [k] > 0.5) 
    {aux.subtotais.performance$positivo.lagged [k] <- 1}
    else
    {aux.subtotais.performance$negativo.lagged  [k] <-  1}
  }
}

# end versão tese2
subtotais.performance.pais <- calcula.subtotais (aux.subtotais.performance$CTR, 
                                    aux.subtotais.performance$positivo,
                                    aux.subtotais.performance$positivo.lagged,
                                    aux.subtotais.performance$negativo,
                                    aux.subtotais.performance$negativo.lagged,NA)
                                     
subtotais.performance.pais <- subtotais.performance.pais [,1:5]

colnames(subtotais.performance.pais) <- c ('Country','Positive performance',
                               'Positive performance - lagged',
                              'Negative performance', 
                              'Negative performance - lagged')

############################################################################################
############################################################################################
# explora governos non-minority para comparar performance
############################################################################################
############################################################################################

saida.non.minority <- saida.basica [saida.basica$ind.minority == 0,]

saida.non.minority <- select (saida.non.minority, c('CTR', 'YR', 'num.total.governos') )

###########################################################################################
#  associando resultados ao proprio ano do governo
############################################################################################

for (k in 1:nrow(saida.non.minority) )
{
  aux.ano.pais.performance <- as.data.frame (
    ind.policy.performance   [ ind.policy.performance$CTR == saida.non.minority$CTR [k] &
                                 ind.policy.performance$YR == as.numeric(saida.non.minority$YR [k]), ]
  )
  saida.non.minority$policy.performance [k]   <-  as.numeric(aux.ano.pais.performance [,3])
  
}


############################################################################################
#  associando resultados ao ano seguinte ao do governo (lagged) 
############################################################################################

for (k in 1:nrow(saida.non.minority) )
{
  if (saida.non.minority$YR [k] < 2018)
    #  descarta a performance lagged de 2018, último ano para o qual há dados de resultado na base 
  {
    aux.ano.pais.performance <- as.data.frame (
      ind.policy.performance   [ ind.policy.performance$CTR == saida.non.minority$CTR [k] &
                                   ind.policy.performance$YR == (as.numeric(saida.non.minority$YR [k]) + 1), ]
    )
    saida.non.minority$policy.performance.lagged [k]   <-  as.numeric(aux.ano.pais.performance [,3])
  } else
  #  carrega vazio na performance lagged para 2018
  {saida.non.minority$policy.performance.lagged [k]   <-  NA}
}



###################################################################################
########################
###########                   MONTA INDICADORES DE CONDIÇÕES CAUSAIS
########################
###################################################################################


############################################################################################
#  cria a estrutura das tabelas-verdade (inicialmente preenchidas com NA)
############################################################################################

#carregamento inicial dos valores
tabela.verdade.mesmo.ano <- relatorio.analitico [, 1:2]
tabela.verdade.mesmo.ano$PRESPOWER <- relatorio.analitico$policy.performance
tabela.verdade.mesmo.ano$PARTYGOALS <- relatorio.analitico$policy.performance
tabela.verdade.mesmo.ano$LEGTHRESHOLD <- relatorio.analitico$policy.performance
tabela.verdade.mesmo.ano$ACCOUNTABILITY <- relatorio.analitico$policy.performance
tabela.verdade.mesmo.ano$OUTCOME <- relatorio.analitico$policy.performance

tabela.verdade.mesmo.ano$PRESPOWER <- NA
tabela.verdade.mesmo.ano$PARTYGOALS <- NA
tabela.verdade.mesmo.ano$LEGTHRESHOLD <- NA
tabela.verdade.mesmo.ano$ACCOUNTABILITY <- NA

#filtro dos valores que têm NA no outcome será feito ao final da 
#  carga de todas as condições causais na tabela verdade


############################################################################################
#  carrega a condição de minimum legislative threshold na tabela verdade
############################################################################################

#  para a tabela verdade mesmo ano
dados.filtrados <- data.frame (tabela.verdade.mesmo.ano$CTR, 
                               tabela.verdade.mesmo.ano$YR,
                               tabela.verdade.mesmo.ano$LEGTHRESHOLD)
colnames(dados.filtrados) <- c ("CTR", "YR", "RESULTADO")
# explorar: muda o minimum threshold de 40 para 45 pct e vice-versa
dados.fonte <- data.frame (saida.basica$CTR,
                           saida.basica$YR,
                           saida.basica$ind.threshold40pct) #<<<< aqui
colnames(dados.fonte) <- c ("CTR", "YR", "ENTRADA")

eh.numerico <- 1

valores.filtrados <- filtra.valores (dados.filtrados, dados.fonte, eh.numerico)

tabela.verdade.mesmo.ano$LEGTHRESHOLD <- valores.filtrados$RESULTADO

############################################################################################
#  monta e calibra os dados de accountability
############################################################################################

# le carga original arquivo IDEA
base.IDEA.original = read_excel("gsodi_v6.1_1975_2021 LatAm editado.xlsx", sheet = "carga", col_names = TRUE)
# formata base original (extrai só a coluna do resultado agregado, converte nome pais para 
#  código padronizado, garante valor numérico ao ano)
base.IDEA.original <- base.IDEA.original[,1:3]
for (k in 1:nrow (base.IDEA.original))
{
  codigo.novo <- converte.nomeingles.codigo (base.IDEA.original$ID_country_name [k])
  base.IDEA.original$ID_country_name [k] <- codigo.novo
base.IDEA.original$ID_year [k] <- as.numeric(base.IDEA.original$ID_year [k])
}

# calibra os dados do indicador para valores fuzzy

parm.crossover <- median(base.IDEA.original$C_SD31)
# explorar: testei limiares de pertencimento mais "duros" para a calibração
#  com base no histograma de raw values (os benchmarks de 0,4 e 0,7 do IDEA
#  foram substituídos por 0,3 e 0,8) <== não houve variação significativa que
#  justificasse afastamento das ancoras substantivas
base.IDEA.original$FUZZY <- calibrate(base.IDEA.original$C_SD31, type = "fuzzy", 
                                      method = "direct", c(0.4, parm.crossover, 0.7)) 
#                                     method = "direct", c(0.3, parm.crossover, 0.8))  # <- aqui
base.IDEA.original$FUZZY <- round(base.IDEA.original$FUZZY, digits = 2)

# substitui eventuais valores 0,5 por 0,51, por opção teórica
for (i in 1:nrow(base.IDEA.original))
{
  if (base.IDEA.original$FUZZY [i] == 0.5)
  {base.IDEA.original$FUZZY [i] <- 0.51 }
}


colnames(base.IDEA.original) <- c ("CTR", "YR", "ACCOUNTABILITY.RAW", "ACCOUNTABILITY.FUZZY")

# dataframe base.IDEA.original vai ser gravado em excel para servir de base a gráficos


############################################################################################
#  carrega a condição de accountability na tabela verdade
############################################################################################

#  filtra os dados para a tabela verdade mesmo ano
dados.filtrados <- data.frame (tabela.verdade.mesmo.ano$CTR, 
                               tabela.verdade.mesmo.ano$YR,
                               tabela.verdade.mesmo.ano$ACCOUNTABILITY)

colnames(dados.filtrados) <- c ("CTR", "YR", "RESULTADO")

dados.fonte <- data.frame (base.IDEA.original$CTR,
                           base.IDEA.original$YR,
                           base.IDEA.original$ACCOUNTABILITY.FUZZY)
colnames(dados.fonte) <- c ("CTR", "YR", "ENTRADA")

eh.numerico <- 1

valores.filtrados <- filtra.valores (dados.filtrados, dados.fonte, eh.numerico)

tabela.verdade.mesmo.ano$ACCOUNTABILITY <- valores.filtrados$RESULTADO

tabela.verdade.mesmo.ano$ACCOUNTABILITY <- round(tabela.verdade.mesmo.ano$ACCOUNTABILITY, digits = 2)


  ## Calibration script - from Online Appendix to Mello, Patrick A. (2021)
  # Direct method of calibration
  # Create the fuzzy-set condition "Fuzzy 1", 
  # using the empirical anchors 10, 30, and 50 for full
  # set non-membership, cross-over, and full set membership
  #DT$Fuzzy1<- calibrate(DT$Raw1, type = "fuzzy", method = "direct", c(10, 30, 50))
  # Round to two digits
  #DT <- round(DT, digits = 2)


#############################################################################
#  carga de polarization
#############################################################################


###
#### indicador political polarization
###

## carrega indicadores selecionados do V-Dem

#                                               o código de país já foi padronizado na carga inicial da base VDem
base.VDem.polarization = data.frame (modelo.VDem.por.pais.data$cod_pais,
                                               modelo.VDem.por.pais.data$year,
                                               modelo.VDem.por.pais.data$v2cacamps_ord) 

colnames(base.VDem.polarization) <- c ("CTR", "YR", "POLARIZATION_RAW")

#  garante valor numérico ao ano
base.VDem.polarization$YR  <- as.numeric(base.VDem.polarization$YR)



# cria as novas colunas fuzzy
base.VDem.polarization$POLARIZATION_FUZZY <- base.VDem.polarization$POLARIZATION_RAW  

base.VDem.polarization$POLARIZATION_FUZZY <- NA


 
# Political polarization : V-Dem variable (v2cacamps)
#Question: Is society polarized into antagonistic, political camps?
#Clarification: Here we refer to the extent to which political differences affect social relationships
#beyond political discussions. Societies are highly polarized if supporters of opposing political
#camps are reluctant to engage in friendly interactions, for example, in family functions, civic
#associations, their free time activities and workplaces
#Responses:
# 0: Not at all. Supporters of opposing political camps generally interact in a friendly manner.
# 1: Mainly not. Supporters of opposing political camps are more likely to interact in a friendly
#Vthan a hostile manner.2: Somewhat. Supporters of opposing political camps are equally likely to interact in a friendly
# or hostile manner. 3: Yes, to noticeable extent. Supporters of opposing political camps are more likely to interact
# in a hostile than friendly manner. 4: Yes, to a large extent. Supporters of opposing political camps generally interact in a hostile
# manner. 
# Assigned respectively fuzzy 0, 0.33, 0.66, 0.75 and 1

for (k in 1:nrow(base.VDem.polarization))
{
  if (base.VDem.polarization$POLARIZATION_RAW [k] == 0 )
  {base.VDem.polarization$POLARIZATION_FUZZY [k]  <- 0}
  if (base.VDem.polarization$POLARIZATION_RAW [k] == 1 )
  {base.VDem.polarization$POLARIZATION_FUZZY [k]  <- 0.33}
  if (base.VDem.polarization$POLARIZATION_RAW [k] == 2 )
  {base.VDem.polarization$POLARIZATION_FUZZY [k]  <- 0.66}
  if (base.VDem.polarization$POLARIZATION_RAW [k] == 3 )
  {base.VDem.polarization$POLARIZATION_FUZZY [k]  <- 0.75}
  if (base.VDem.polarization$POLARIZATION_RAW [k] == 4 )
  {base.VDem.polarization$POLARIZATION_FUZZY [k]  <- 1}
} # end-for  

#  filtra dados de polarization para os anos-país da tabela-verdade
#  para a tabela verdade mesmo ano
dados.filtrados <- data.frame (tabela.verdade.mesmo.ano$CTR, 
                               tabela.verdade.mesmo.ano$YR,
                               tabela.verdade.mesmo.ano$LEGTHRESHOLD)

colnames(dados.filtrados) <- c ("CTR", "YR", "RESULTADO")
dados.filtrados$RESULTADO <- NA  # evitar arraste indevido de valores da tabela original

dados.fonte <- data.frame (base.VDem.polarization$CTR,
                           base.VDem.polarization$YR,
                           base.VDem.polarization$POLARIZATION_FUZZY)

colnames(dados.fonte) <- c ("CTR", "YR", "ENTRADA")

eh.numerico <- 1

valores.filtrados <- filtra.valores (dados.filtrados, dados.fonte, eh.numerico)

aux.polarization <- valores.filtrados
colnames(aux.polarization) <- c ("CTR", "YR", "POLARIZATION")

tabela.verdade.mesmo.ano$POLARIZATION <- aux.polarization$POLARIZATION

#############################################################################
#  fim da carga de polarization  
#############################################################################


############################################################################################
#  carrega a condição de reconcilability of party goals na tabela verdade
############################################################################################

###
#### indicador volatilidade
###

## le planilha com as volatilidades compiladas a partir da fonte (Mainwaring & Su, 2021)
base.volatility = read_excel("Volatility.xlsx", sheet = "Volatility", col_names = TRUE)


# calibra os dados do indicador para valores fuzzy

# tomando como crossover a média latino-americana a partir de 1990
parm.institutionalized.system <- base.volatility [(base.volatility$YR > 1989), ] 
parm.crossover <- mean (parm.institutionalized.system$VOLATILITY_RAW)

#explorar: abri os limiares de pertencimento para volatility para valores menores
#  (5% em vez de 0, 95%, em vez de 1), para abranger no limite superior volatilidades
# muito baixas e muito altas mesmo que não respondam aos limites teóricos

base.volatility$VOLATILITY_FUZZY_LatAm <- calibrate(base.volatility$VOLATILITY_RAW, type = "fuzzy", 
                                              # method = "direct", c(0, parm.crossover, 100))  <-- aqui
                                              method = "direct", c(5, parm.crossover, 90))  # <-- aqui
base.volatility$VOLATILITY_FUZZY_LatAm <- round(base.volatility$VOLATILITY_FUZZY_LatAm, digits = 2)

# tomando como crossover a média histórica da Europa Ocidental (Bartolini& Mair, 1990)
parm.crossover <- 7.93  # valor numérico dessa média


base.volatility$VOLATILITY_FUZZY_Eur <- calibrate(base.volatility$VOLATILITY_RAW, type = "fuzzy", 
                                                    #method = "direct", c(0, parm.crossover, 100)) <--aqui
                                                    method = "direct", c(5, parm.crossover, 90)) #  <-- aqui

base.volatility$VOLATILITY_FUZZY_Eur <- round(base.volatility$VOLATILITY_FUZZY_Eur, digits = 2)

# dataframe base.volatility vai ser gravado em excel para servir de base a gráficos



#  filtra dados de volatilidade para os anos-pais da tabela-verdade

#  para a tabela verdade mesmo ano
dados.filtrados <- data.frame (tabela.verdade.mesmo.ano$CTR, 
                               tabela.verdade.mesmo.ano$YR,
                               tabela.verdade.mesmo.ano$LEGTHRESHOLD)

colnames(dados.filtrados) <- c ("CTR", "YR", "RESULTADO")
dados.filtrados$RESULTADO <- NA  # evitar arraste indevido de valores da tabela original

# escolhidos os dados calibrados com a média latino-americana pós-1990
dados.fonte <- data.frame (base.volatility$CTR,
                           base.volatility$YR,
                           base.volatility$VOLATILITY_FUZZY_LatAm)

colnames(dados.fonte) <- c ("CTR", "YR", "ENTRADA")

eh.numerico <- 1

valores.filtrados <- filtra.valores (dados.filtrados, dados.fonte, eh.numerico)

aux.partygoals <- valores.filtrados
colnames(aux.partygoals) <- c ("CTR", "YR", "VOLATILITY")

###
#### indicador oppositional influence
###

## carrega indicadores selecionados do V-Dem

#                                               o código de país já foi padronizado na carga inicial da base VDem
base.VDem.oppositional.influence = data.frame (modelo.VDem.por.pais.data$cod_pais,
                                               modelo.VDem.por.pais.data$year,
                                               modelo.VDem.por.pais.data$v2dlconslt_ord,
                                               modelo.VDem.por.pais.data$v2dlcountr_ord) 

colnames(base.VDem.oppositional.influence) <- c ("CTR", "YR", "CONSULTATION_RAW","COUNTERARGUMENT_RAW")

#  garante valor numérico ao ano
base.VDem.oppositional.influence$YR  <- as.numeric(base.VDem.oppositional.influence$YR)


##  explorar:
#  following Rutten (2020) that semantically is inadequate to make the same
# kind of calibration from a continuous variable and from an ordinal one.
# those two ordinal variables were directly assigned fuzzy values from their 
# ordinal scales

# original version
#  tira a média das duas variáveis
# base.VDem.oppositional.influence$AVERAGE_RAW  <- (base.VDem.oppositional.influence$CONSULTATION_RAW + base.VDem.oppositional.influence$COUNTERARGUMENT_RAW) / 2
#  calibra a média numérica para valores fuzzy
#base.VDem.oppositional.influence$AVERAGE_FUZZY  <- calibrate (base.VDem.oppositional.influence$AVERAGE_RAW, type = "fuzzy", 
#                                                  method = "direct", c(0,3,5) )


# renewed version

# cria as novas colunas fuzzy
base.VDem.oppositional.influence$CONSULTATION_FUZZY <- base.VDem.oppositional.influence$CONSULTATION_RAW  
base.VDem.oppositional.influence$COUNTERARGUMENT_FUZZY <- base.VDem.oppositional.influence$COUNTERARGUMENT_RAW

base.VDem.oppositional.influence$CONSULTATION_FUZZY <- NA
base.VDem.oppositional.influence$COUNTERARGUMENT_FUZZY <- NA


# Range of consultation at elite levels: V-Dem variable v2dlconslt ==> 
# 0 - No consultation; 1 - Very little and narrow (ruling party/elite); 
# 2 - Former, plus larger loyalist groups; 3 - Former, plus other parties´leaders; 
# 4 - Former, plus select societal representatives; 5 - All political elites and
# all societal groups
# Assigned respectively fuzzy 0, 0,25, 0,33, 0,66, 0,75 and 1 

for (k in 1:nrow(base.VDem.oppositional.influence))
{
  if (base.VDem.oppositional.influence$CONSULTATION_RAW [k] == 0 )
  {base.VDem.oppositional.influence$CONSULTATION_FUZZY [k]  <- 0}
  if (base.VDem.oppositional.influence$CONSULTATION_RAW [k] == 1 )
  {base.VDem.oppositional.influence$CONSULTATION_FUZZY [k]  <- 0.25}
  if (base.VDem.oppositional.influence$CONSULTATION_RAW [k] == 2 )
  {base.VDem.oppositional.influence$CONSULTATION_FUZZY [k]  <- 0.33}
  if (base.VDem.oppositional.influence$CONSULTATION_RAW [k] == 3 )
  {base.VDem.oppositional.influence$CONSULTATION_FUZZY [k]  <- 0.66}
  if (base.VDem.oppositional.influence$CONSULTATION_RAW [k] == 4 )
  {base.VDem.oppositional.influence$CONSULTATION_FUZZY [k]  <- 0.75}
  if (base.VDem.oppositional.influence$CONSULTATION_RAW [k] == 5 )
  {base.VDem.oppositional.influence$CONSULTATION_FUZZY [k]  <- 1}
} # end-for  


# Acknowledgement and respect for counterarguments: V-Dem variable v2dlcountr ==> 
# 0 - Not allowed/repressed; 1 - Somehow tolerated but ignored; 2 - Acknowledged 
# but degraded ostensibly; 3 - Acknowledged; 4 Acknowledged and inducted into serious
# discussion, mostely rejected; 5- Acknowledged, valued and often accepted
# Assigned respectively fuzzy 0, 0,25, 0,33, 0,33, 0,66 and 1  (values 2 and 3
# have no perceived influence on policy, differ only in the discussion/deliberation
# settings) 

for (k in 1:nrow(base.VDem.oppositional.influence))
{
  if (base.VDem.oppositional.influence$COUNTERARGUMENT_RAW [k] == 0 )
  {base.VDem.oppositional.influence$COUNTERARGUMENT_FUZZY [k]  <- 0}
  if (base.VDem.oppositional.influence$COUNTERARGUMENT_RAW [k] == 1 )
  {base.VDem.oppositional.influence$COUNTERARGUMENT_FUZZY [k]  <- 0.25}
  if (base.VDem.oppositional.influence$COUNTERARGUMENT_RAW [k] == 2 )
  {base.VDem.oppositional.influence$COUNTERARGUMENT_FUZZY [k]  <- 0.33}
  if (base.VDem.oppositional.influence$COUNTERARGUMENT_RAW [k] == 3 )
  {base.VDem.oppositional.influence$COUNTERARGUMENT_FUZZY [k]  <- 0.33}
  if (base.VDem.oppositional.influence$COUNTERARGUMENT_RAW [k] == 4 )
  {base.VDem.oppositional.influence$COUNTERARGUMENT_FUZZY [k]  <- 0.66}
  if (base.VDem.oppositional.influence$COUNTERARGUMENT_RAW [k] == 5 )
  {base.VDem.oppositional.influence$COUNTERARGUMENT_FUZZY [k]  <- 1}
} # end-for  

# used Fuzzy AND to reach an overall index (akin to the numerical average)
# substantively, both consultation and acknowledgement of arguments must
# be met to reach some degree of oppositional influence over policy
base.VDem.oppositional.influence$AVERAGE_FUZZY  <- fuzzyand (
  base.VDem.oppositional.influence$CONSULTATION_FUZZY,               
  base.VDem.oppositional.influence$COUNTERARGUMENT_FUZZY)


#  filtra dados de oppositional influence para os anos-país da tabela-verdade

#  para a tabela verdade mesmo ano
dados.filtrados <- data.frame (tabela.verdade.mesmo.ano$CTR, 
                               tabela.verdade.mesmo.ano$YR,
                               tabela.verdade.mesmo.ano$LEGTHRESHOLD)

colnames(dados.filtrados) <- c ("CTR", "YR", "RESULTADO")
dados.filtrados$RESULTADO <- NA  # evitar arraste indevido de valores da tabela original

dados.fonte <- data.frame (base.VDem.oppositional.influence$CTR,
                           base.VDem.oppositional.influence$YR,
                           base.VDem.oppositional.influence$AVERAGE_FUZZY)

colnames(dados.fonte) <- c ("CTR", "YR", "ENTRADA")

eh.numerico <- 1

valores.filtrados <- filtra.valores (dados.filtrados, dados.fonte, eh.numerico)

aux.partygoals$OPPOSITIONAL.INFLUENCE <- valores.filtrados$RESULTADO

###
#### combina volatility e oppositional influence (gera "electoral policy bargaining potential")
###

## gera a interseção entre os dois vetores volatility e oppositional influence


aux.partygoals$BARGAINING.POTENTIAL <- aux.partygoals$OPPOSITIONAL.INFLUENCE
aux.partygoals$BARGAINING.POTENTIAL <- NA  # evitar arraste indevido de valores da tabela original

aux.partygoals$BARGAINING.POTENTIAL <- fuzzyand (aux.partygoals$OPPOSITIONAL.INFLUENCE,
                                              aux.partygoals$VOLATILITY)



###
#### indicador particularistic motivation of party system
###

## carrega indicadores selecionados do V-Dem

#                                               o código de país já foi padronizado na carga inicial da base VDem
base.VDem.particularistic.system = data.frame (modelo.VDem.por.pais.data$cod_pais,
                                               modelo.VDem.por.pais.data$year,
                                               modelo.VDem.por.pais.data$v2dlencmps_ord,
                                               modelo.VDem.por.pais.data$v2elvotbuy_ord,
                                               modelo.VDem.por.pais.data$v2psprlnks_ord) 

colnames(base.VDem.particularistic.system) <- c ("CTR", "YR", "PUBLIC.GOODS_RAW",
                                                 "VOTE.BUYING_RAW",
                                                 "PARTY.LINKAGES_RAW")

#  garante valor numérico ao ano
base.VDem.particularistic.system$YR  <- as.numeric(base.VDem.particularistic.system$YR)

##  explorar:
#  following Rutten (2020) that semantically is inadequate to make the same
# kind of calibration from a continuous variable and from an ordinal one.
# those two ordinal variables were directly assigned fuzzy values from their 
# ordinal scales

# original version
#  calibra cada variável para valores fuzzy
   # if threshold parameters in calibrate are like "i < c < < e" 
   #     ("e"	= full set exclusion, "c"	=  crossover, "i"	= full set inclusion)
   # then the membership function is decreasing from i to e
#base.VDem.particularistic.system$PUBLIC.GOODS_FUZZY  <- calibrate (base.VDem.particularistic.system$PUBLIC.GOODS_RAW, type = "fuzzy", 
#                                                              method = "direct", c(4,3,0) )
#base.VDem.particularistic.system$VOTE.BUYING_FUZZY  <- calibrate (base.VDem.particularistic.system$VOTE.BUYING_RAW, type = "fuzzy", 
#                                                                   method = "direct", c(4,2,0) )


#base.VDem.particularistic.system$PARTY.LINKAGES_FUZZY  <- calibrate (base.VDem.particularistic.system$PARTY.LINKAGES_RAW, type = "fuzzy", 
#                                                                  method = "direct", c(4,2,0) )

# renewed version
# Public goods: V-Dem variable v2dlencmps ==> 0 - almost all particularistic; 1 - 
# most particularistic (1/3 to 1/4 public-oriented); 2 - evenly divided; 3 - most
# public-goods (1/3 to 1/4 particularistic); 4 - almost all public goods
# Assigned respectively fuzzy 1, 0,75, 0,66, 0,33, and 0  (substantively, half
# particularistic is assigned a positive membership, for it´s still a lot of pork)
for (k in 1:nrow(base.VDem.particularistic.system))
{
  if (base.VDem.particularistic.system$PUBLIC.GOODS_RAW [k] == 0 )
    {base.VDem.particularistic.system$PUBLIC.GOODS_FUZZY [k]  <-1}
  if (base.VDem.particularistic.system$PUBLIC.GOODS_RAW [k] == 1 )
    {base.VDem.particularistic.system$PUBLIC.GOODS_FUZZY [k]  <-0.75}
  if (base.VDem.particularistic.system$PUBLIC.GOODS_RAW [k] == 2 )
    {base.VDem.particularistic.system$PUBLIC.GOODS_FUZZY [k]  <-0.66}
  if (base.VDem.particularistic.system$PUBLIC.GOODS_RAW [k] == 3 )
    {base.VDem.particularistic.system$PUBLIC.GOODS_FUZZY  [k] <-0.33}
  if (base.VDem.particularistic.system$PUBLIC.GOODS_RAW [k] == 4 )
    {base.VDem.particularistic.system$PUBLIC.GOODS_FUZZY [k]  <-0}
} # end-for
# Party linkages: V-Dem variable v2psprlnks ==> 0 - Fully clientelistic; 
# 1 - Mixed clientelistic and local collective; 2 - Local collective; 3 - 
#  mixed local collective and policy/programatic; 4 - Full policy/programmatic
# Assigned respectively fuzzy 1, 0,75, 0,66, 0,33, and 0  (substantively, local 
# collective is still assigned a positive membership, for it remains attracted by
# pork and other clientelistic bargains, although in a wider constituency

for (k in 1:nrow(base.VDem.particularistic.system))
{
  if (base.VDem.particularistic.system$PARTY.LINKAGES_RAW [k] == 0 )
    {base.VDem.particularistic.system$PARTY.LINKAGES_FUZZY  [k] <-1}
  if (base.VDem.particularistic.system$PARTY.LINKAGES_RAW [k] == 1 )
    {base.VDem.particularistic.system$PARTY.LINKAGES_FUZZY  [k] <-0.75}
  if (base.VDem.particularistic.system$PARTY.LINKAGES_RAW [k] == 2 )
    {base.VDem.particularistic.system$PARTY.LINKAGES_FUZZY  [k] <-0.66}
  if (base.VDem.particularistic.system$PARTY.LINKAGES_RAW [k] == 3 )
    {base.VDem.particularistic.system$PARTY.LINKAGES_FUZZY  [k] <-0.33}
  if (base.VDem.particularistic.system$PARTY.LINKAGES_RAW [k] == 4 )
    {base.VDem.particularistic.system$PARTY.LINKAGES_FUZZY  [k] <-0}
} # end-for
  
  
#  esta seleção indicou que VoteBuying (v2elvotbuy_ord) está demasiadamente 
#  cheio de buracos ("NA"), descartado para uso analítico  

base.VDem.particularistic.system$PARTICULARISTIC.SYSTEM  <- fuzzyor (
            base.VDem.particularistic.system$PUBLIC.GOODS_FUZZY,               
            base.VDem.particularistic.system$PARTY.LINKAGES_FUZZY   )


#  filtra dados de public goods ara os anos-país da tabela-verdade

#  para a tabela verdade mesmo ano
dados.filtrados <- data.frame (tabela.verdade.mesmo.ano$CTR, 
                               tabela.verdade.mesmo.ano$YR,
                               tabela.verdade.mesmo.ano$LEGTHRESHOLD)

colnames(dados.filtrados) <- c ("CTR", "YR", "RESULTADO")
dados.filtrados$RESULTADO <- NA  # evitar arraste indevido de valores da tabela original

dados.fonte <- data.frame (base.VDem.particularistic.system$CTR,
                           base.VDem.particularistic.system$YR,
                           base.VDem.particularistic.system$PUBLIC.GOODS_FUZZY)

colnames(dados.fonte) <- c ("CTR", "YR", "ENTRADA")

eh.numerico <- 1

valores.filtrados <- filtra.valores (dados.filtrados, dados.fonte, eh.numerico)

aux.partygoals$PUBLIC.GOODS <- valores.filtrados$RESULTADO



#  filtra dados de party linkages para os anos-país da tabela-verdade

#  para a tabela verdade mesmo ano
dados.filtrados <- data.frame (tabela.verdade.mesmo.ano$CTR, 
                               tabela.verdade.mesmo.ano$YR,
                               tabela.verdade.mesmo.ano$LEGTHRESHOLD)

colnames(dados.filtrados) <- c ("CTR", "YR", "RESULTADO")
dados.filtrados$RESULTADO <- NA  # evitar arraste indevido de valores da tabela original

dados.fonte <- data.frame (base.VDem.particularistic.system$CTR,
                           base.VDem.particularistic.system$YR,
                           base.VDem.particularistic.system$PARTY.LINKAGES_FUZZY)

colnames(dados.fonte) <- c ("CTR", "YR", "ENTRADA")

eh.numerico <- 1

valores.filtrados <- filtra.valores (dados.filtrados, dados.fonte, eh.numerico)

aux.partygoals$PARTY.LINKAGES <- valores.filtrados$RESULTADO


## gera a união entre os dois vetores public goods and party linkages


aux.partygoals$PARTICULARISTIC.SYSTEM <- aux.partygoals$PARTY.LINKAGES
aux.partygoals$PARTICULARISTIC.SYSTEM <- NA  # evitar arraste indevido de valores da tabela original

aux.partygoals$PARTICULARISTIC.SYSTEM <- fuzzyor (aux.partygoals$PARTY.LINKAGES,
                                                 aux.partygoals$PUBLIC.GOODS)



###
#### composição definitiva do indicador reconcilability of party goals
###

#para a tabela verdade no mesmo ano
aux.partygoals$PARTY.GOALS <- aux.partygoals$PARTY.LINKAGES
aux.partygoals$PARTY.GOALS <- NA  # evitar arraste indevido de valores da tabela original

for (k in (1:nrow(aux.partygoals)))
{
  if ( (aux.partygoals$BARGAINING.POTENTIAL [k] > 0.5) &
       (aux.partygoals$PARTICULARISTIC.SYSTEM [k] > 0.5) )
        # both intermediate conditions have values higher than 0,5: final
        #  fuzzy value is their union, with a 0,75 floor
      { 
         aux.partygoals$PARTY.GOALS [k] <- fuzzyor(aux.partygoals$BARGAINING.POTENTIAL [k],
                                                   aux.partygoals$PARTICULARISTIC.SYSTEM [k])
         
         if (aux.partygoals$PARTY.GOALS [k] < 0.75)
         {aux.partygoals$PARTY.GOALS [k] <- 0.75}
     }
   else
   { 
     if ( (aux.partygoals$BARGAINING.POTENTIAL [k] > 0.5) |
          (aux.partygoals$PARTICULARISTIC.SYSTEM [k] > 0.5) )
       # only one of the intermediaries exceeds 0,5:final value will be
       # this higher isolated value, capped at 0,75 
       {
       aux.partygoals$PARTY.GOALS [k] <- fuzzyor(aux.partygoals$BARGAINING.POTENTIAL [k],
                                                 aux.partygoals$PARTICULARISTIC.SYSTEM [k])
       
       if (aux.partygoals$PARTY.GOALS [k] > 0.75)
       {aux.partygoals$PARTY.GOALS [k] <- 0.75}
      }
      else
        # no condition exceeds 0,5: the final value will be the 
        # multiplication/intersection (logical “AND”) of both.
      {
        aux.partygoals$PARTY.GOALS [k] <- fuzzyand(aux.partygoals$BARGAINING.POTENTIAL [k],
                                                  aux.partygoals$PARTICULARISTIC.SYSTEM [k])
      }
   }  
} #endfor

tabela.verdade.mesmo.ano$PARTYGOALS <- aux.partygoals$PARTY.GOALS


############################################################################################
#  carrega a condição de presidential powers na tabela verdade
############################################################################################

###
#### valores de legislative powers
###



## le planilha com os valores já convertidos em fuzzy
## (as três últimas colunas são totalizações dos diferentes poderes,
##   conforme a formulação analítica no texto)
base.prespowers.leg <- read_excel("Legislative Powers.xlsx", sheet = "LEG Data in fuzzy", col_names = TRUE)


#  filtra valores finais de legislative powers para os anos-país da 
#  tabela-verdade

# monta primeira coluna de dados

aux.prespowers.leg <- base.prespowers.leg [,1:3]

dados.filtrados <- data.frame (tabela.verdade.mesmo.ano$CTR, 
                               tabela.verdade.mesmo.ano$YR,
                               tabela.verdade.mesmo.ano$LEGTHRESHOLD)

colnames(dados.filtrados) <- c ("CTR", "YR", "RESULTADO")
dados.filtrados$RESULTADO <- NA  # evitar arraste indevido de valores da tabela original

dados.fonte <- aux.prespowers.leg

colnames(dados.fonte) <- c ("CTR", "YR", "ENTRADA")

eh.numerico <- 1

valores.filtrados <- filtra.valores (dados.filtrados, dados.fonte, eh.numerico)

aux.prespowers.leg <- valores.filtrados

# monta demais colunas de dados


for (j in 4:ncol(base.prespowers.leg))  
                                             
{
  
  dados.filtrados <- data.frame (tabela.verdade.mesmo.ano$CTR, 
                               tabela.verdade.mesmo.ano$YR,
                               tabela.verdade.mesmo.ano$LEGTHRESHOLD)

  colnames(dados.filtrados) <- c ("CTR", "YR", "RESULTADO")
  dados.filtrados$RESULTADO <- NA  # evitar arraste indevido de valores da tabela original

  dados.fonte <- data.frame (base.prespowers.leg$CTR,
                           base.prespowers.leg$YR,
                           base.prespowers.leg[,j])

  colnames(dados.fonte) <- c ("CTR", "YR", "ENTRADA")

  eh.numerico <- 1

  valores.filtrados <- filtra.valores (dados.filtrados, dados.fonte, eh.numerico)

  aux.prespowers.leg [,j] <- valores.filtrados$RESULTADO

} #endfor

# retorna as colunas à denominação original

colnames(aux.prespowers.leg) <- colnames (base.prespowers.leg)

aux.prespowers.leg <- subset(aux.prespowers.leg, select = 
                               -c ( ncol(aux.prespowers.leg),
                                    (ncol (aux.prespowers.leg) - 1),
                                    (ncol (aux.prespowers.leg) - 2)  ))

## retira as três últimas colunas, que são totalizações dos diferentes poderes)

###
#### valores de budget powers
###



## le planilha com os valores já convertidos em fuzzy
base.prespowers.budg <- read_excel("Budget Powers.xlsx", sheet = "BUDG Data in fuzzy", col_names = TRUE)


#  filtra valores finais de budget powers para os anos-país da 
#  tabela-verdade

# monta primeira coluna de dados

aux.prespowers.budg <- base.prespowers.budg [,1:3]

dados.filtrados <- data.frame (tabela.verdade.mesmo.ano$CTR, 
                               tabela.verdade.mesmo.ano$YR,
                               tabela.verdade.mesmo.ano$LEGTHRESHOLD)

colnames(dados.filtrados) <- c ("CTR", "YR", "RESULTADO")
dados.filtrados$RESULTADO <- NA  # evitar arraste indevido de valores da tabela original

dados.fonte <- aux.prespowers.budg

colnames(dados.fonte) <- c ("CTR", "YR", "ENTRADA")

eh.numerico <- 1

valores.filtrados <- filtra.valores (dados.filtrados, dados.fonte, eh.numerico)

aux.prespowers.budg <- valores.filtrados

# monta demais colunas de dados

for (j in 4:ncol(base.prespowers.budg))
{
  
  dados.filtrados <- data.frame (tabela.verdade.mesmo.ano$CTR, 
                                 tabela.verdade.mesmo.ano$YR,
                                 tabela.verdade.mesmo.ano$LEGTHRESHOLD)
  
  colnames(dados.filtrados) <- c ("CTR", "YR", "RESULTADO")
  dados.filtrados$RESULTADO <- NA  # evitar arraste indevido de valores da tabela original
  
  dados.fonte <- data.frame (base.prespowers.budg$CTR,
                             base.prespowers.budg$YR,
                             base.prespowers.budg[,j])
  
  colnames(dados.fonte) <- c ("CTR", "YR", "ENTRADA")
  
  eh.numerico <- 1
  
  valores.filtrados <- filtra.valores (dados.filtrados, dados.fonte, eh.numerico)
  
  aux.prespowers.budg [,j] <- valores.filtrados$RESULTADO
  
} #endfor

# retorna as colunas à denominação original

colnames(aux.prespowers.budg) <- colnames (base.prespowers.budg)

###
#### valores de informal powers
###


## carrega indicadores selecionados do V-Dem

#                                               o código de país já foi padronizado na carga inicial da base VDem
base.VDem.informal.powers = data.frame (modelo.VDem.por.pais.data$cod_pais,
                                               modelo.VDem.por.pais.data$year,
                                               modelo.VDem.por.pais.data$v2lgcrrpt_ord,
                                               modelo.VDem.por.pais.data$v2xnp_regcorr,
                                               modelo.VDem.por.pais.data$v2stcritrecadm_ord) 

colnames(base.VDem.informal.powers) <- c ("CTR", "YR", "CORRUPT_LEG_RAW",
                                      "CORRUPT_POL_ACTORS_RAW",
                                      "PATRONAGE_RAW")



#####################################
####  imputação direta de dados para a lacuna de patronage no Peru
####  imputação retroativa do valor de 2005 para o período de 1978-2004
####  cfe. nota section A.4.2.3
#####################################

valor.imputado <- base.VDem.informal.powers$PATRONAGE_RAW [ (base.VDem.informal.powers$CTR == "PE") & 
                       (base.VDem.informal.powers$YR == 2005) ]

for (i in 1:nrow (base.VDem.informal.powers))
{
  if ( (base.VDem.informal.powers$CTR [i] == "PE") &
       (is.na (base.VDem.informal.powers$PATRONAGE_RAW [i])) )
  {
    base.VDem.informal.powers$PATRONAGE_RAW [i] <- valor.imputado
  }
}


#  calibra cada variável para valores fuzzy
# if threshold parameters in calibrate are like "i < c < < e" 
#     ("e"	= full set exclusion, "c"	=  crossover, "i"	= full set inclusion)
# then the membership function is decreasing from i to e

# temporário para teste

base.VDem.informal.powers$CORRUPT_POL_ACTORS_FUZZY <- base.VDem.informal.powers$CORRUPT_POL_ACTORS_RAW
base.VDem.informal.powers$PATRONAGE_FUZZY <- base.VDem.informal.powers$PATRONAGE_RAW

# calibrating legislative corruption directly from the qualitative
#  values from the ordinal survey response data

base.VDem.informal.powers$CORRUPT_LEG_FUZZY <- base.VDem.informal.powers$CORRUPT_LEG_RAW
for (k in 1:nrow(base.VDem.informal.powers))
{
  if (is.na (base.VDem.informal.powers$CORRUPT_LEG_RAW [k]))
  {base.VDem.informal.powers$CORRUPT_LEG_FUZZY [k]<- NA }
  else
  {
  if (base.VDem.informal.powers$CORRUPT_LEG_RAW [k] == 0)
  { base.VDem.informal.powers$CORRUPT_LEG_FUZZY [k]<- 1  }
  
  if (base.VDem.informal.powers$CORRUPT_LEG_RAW [k] == 1)
  { base.VDem.informal.powers$CORRUPT_LEG_FUZZY [k] <- 0.66 }
  
  if (base.VDem.informal.powers$CORRUPT_LEG_RAW [k] == 2)
  { base.VDem.informal.powers$CORRUPT_LEG_FUZZY [k] <- 0.33 }
  
  if (base.VDem.informal.powers$CORRUPT_LEG_RAW [k] == 3)
  { base.VDem.informal.powers$CORRUPT_LEG_FUZZY [k] <- 0.25 }
  
  if (base.VDem.informal.powers$CORRUPT_LEG_RAW [k] == 4)
  { base.VDem.informal.powers$CORRUPT_LEG_FUZZY [k] <- 0 }
  }
}


# calibrating political system corruption 

# explorar: fixei parâmetros mais amplos para pertencimento e não pertencimento
#  (0,05 em vez de 0,e 0,95 em vez de 1); 
# mudei também o crossover para a mediana

parm.crossover <- median(base.VDem.informal.powers$CORRUPT_POL_ACTORS_RAW)  # <-- aqui
# parm.crossover <- mean(base.VDem.informal.powers$CORRUPT_POL_ACTORS_RAW) <--aqui
# found mean = 0.5848085 ; found median = 0.622


base.VDem.informal.powers$CORRUPT_POL_ACTORS_FUZZY <- calibrate (base.VDem.informal.powers$CORRUPT_POL_ACTORS_RAW, type = "fuzzy", 
                          # method = "direct", c(0,parm.crossover,1) )
                          method = "direct", c(0.05,parm.crossover,0.95) ) # <-- aqui

# calibrating patronage directly from the qualitative
#  values from the ordinal survey response data

base.VDem.informal.powers$PATRONAGE_FUZZY <- base.VDem.informal.powers$PATRONAGE_RAW

for (k in 1:nrow(base.VDem.informal.powers))
{
  if (is.na (base.VDem.informal.powers$PATRONAGE_RAW [k]))
  {base.VDem.informal.powers$PATRONAGE_FUZZY [k]<- NA }
  else
  {
    if (base.VDem.informal.powers$PATRONAGE_RAW [k] == 0)
    { base.VDem.informal.powers$PATRONAGE_FUZZY [k]<- 1  }
    
    if (base.VDem.informal.powers$PATRONAGE_RAW [k] == 1)
    { base.VDem.informal.powers$PATRONAGE_FUZZY [k] <- 0.66 }
    
    if (base.VDem.informal.powers$PATRONAGE_RAW [k] == 2)
    { base.VDem.informal.powers$PATRONAGE_FUZZY [k] <- 0.33 }
    
    if (base.VDem.informal.powers$PATRONAGE_RAW [k] == 3)
    { base.VDem.informal.powers$PATRONAGE_FUZZY [k] <- 0.25 }
    
    if (base.VDem.informal.powers$PATRONAGE_RAW [k] == 4)
    { base.VDem.informal.powers$PATRONAGE_FUZZY [k] <- 0 }
  }
}


#  filtra dados dos três indicadores informais para a mesma
#  estrutura de ano-país da tabela verdade



#  filtra dados de legislative corruption para os anos-país da 
#  tabela-verdade

dados.filtrados <- data.frame (tabela.verdade.mesmo.ano$CTR, 
                               tabela.verdade.mesmo.ano$YR,
                               tabela.verdade.mesmo.ano$LEGTHRESHOLD)

colnames(dados.filtrados) <- c ("CTR", "YR", "RESULTADO")
dados.filtrados$RESULTADO <- NA  # evitar arraste indevido de valores da tabela original

dados.fonte <- data.frame (base.VDem.informal.powers$CTR,
                           base.VDem.informal.powers$YR,
                           base.VDem.informal.powers$CORRUPT_LEG_FUZZY)

colnames(dados.fonte) <- c ("CTR", "YR", "ENTRADA")

eh.numerico <- 1

valores.filtrados <- filtra.valores (dados.filtrados, dados.fonte, eh.numerico)


aux.prespowers.informal <- valores.filtrados

colnames(aux.prespowers.informal) <- c ("CTR", "YR", "CORRUPT_LEG_FUZZY")
                                        
#  filtra dados de political system corruption para os anos-país da 
#  tabela verdade


dados.filtrados <- data.frame (tabela.verdade.mesmo.ano$CTR, 
                               tabela.verdade.mesmo.ano$YR,
                               tabela.verdade.mesmo.ano$LEGTHRESHOLD)

colnames(dados.filtrados) <- c ("CTR", "YR", "RESULTADO")
dados.filtrados$RESULTADO <- NA  # evitar arraste indevido de valores da tabela original

dados.fonte <- data.frame (base.VDem.informal.powers$CTR,
                           base.VDem.informal.powers$YR,
                           base.VDem.informal.powers$CORRUPT_POL_ACTORS_RAW)
                             

colnames(dados.fonte) <- c ("CTR", "YR", "ENTRADA")

eh.numerico <- 1

valores.filtrados <- filtra.valores (dados.filtrados, dados.fonte, eh.numerico)

aux.prespowers.informal$CORRUPT_POL_ACTORS_FUZZY <- valores.filtrados$RESULTADO


#  filtra dados de patronage para os anos-país da 
#  estrutura auxiliar (aux.prespowers.informal)


dados.filtrados <- data.frame (tabela.verdade.mesmo.ano$CTR, 
                               tabela.verdade.mesmo.ano$YR,
                               tabela.verdade.mesmo.ano$LEGTHRESHOLD)

colnames(dados.filtrados) <- c ("CTR", "YR", "RESULTADO")
dados.filtrados$RESULTADO <- NA  # evitar arraste indevido de valores da tabela original

dados.fonte <- data.frame (base.VDem.informal.powers$CTR,
                           base.VDem.informal.powers$YR,
                           base.VDem.informal.powers$PATRONAGE_FUZZY)

colnames(dados.fonte) <- c ("CTR", "YR", "ENTRADA")

eh.numerico <- 1

valores.filtrados <- filtra.valores (dados.filtrados, dados.fonte, eh.numerico)

aux.prespowers.informal$PATRONAGE_FUZZY <- valores.filtrados$RESULTADO


######
########  montagem final do indicador de informal powers
########  (CORRUPT_POL_ACTORS AND CORRUPT_LEG) OR (PATRONAGE) 
######

aux.prespowers.informal$INFORMAL_POWERS <- fuzzyand(aux.prespowers.informal$CORRUPT_LEG_FUZZY,
                                                    aux.prespowers.informal$CORRUPT_POL_ACTORS_FUZZY)

aux.prespowers.informal$INFORMAL_POWERS <- fuzzyor(aux.prespowers.informal$INFORMAL_POWERS,
                                                    aux.prespowers.informal$PATRONAGE_FUZZY)


######
########  composição final do indicador de presidential powers
########  - unifica as colunas num mesmo dataframe
########  - totaliza os diferentes tipos de poderes para obter o fuzzy final
######

# unifica as colunas
  aux.totaliza.prespowers <- aux.prespowers.leg
 
  # acrescenta as colunas de poderes orçamentários
     aux.totaliza.prespowers$VIREMENT <- aux.prespowers.budg$VIREMENT
     aux.totaliza.prespowers$BUDGET_DECREE <- aux.prespowers.budg$BUDGET_DECREE
     aux.totaliza.prespowers$IMPOUNDMENT <- aux.prespowers.budg$IMPOUNDMENT
     aux.totaliza.prespowers$REVERSIONARY <- aux.prespowers.budg$REVERSIONARY
     aux.totaliza.prespowers$AMENDMENT <- aux.prespowers.budg$AMENDMENT
  # acrescenta a coluna de poderes INFORMAIS
     aux.totaliza.prespowers$INFORMAL_POWERS <- as.numeric(aux.prespowers.informal$INFORMAL_POWERS)
   # cria e zera a coluna de resultado final
     aux.totaliza.prespowers$PRESPOWERS <- aux.prespowers.informal$INFORMAL_POWERS
     aux.totaliza.prespowers$PRESPOWERS <-  NA

     variables.unilateral <- c("VETO_TOTAL", "VETO_PARTIAL", "DECREE","VIREMENT",
                               "BUDGET_DECREE", "IMPOUNDMENT")       
     variables.bargaining <- c("EXC_INIT", "AG_FLOOR_DEFAULT", "REVERSIONARY", 
                               "AMENDMENT", "AG_FLOOR_OVERRIDE", "COMM_MEMBER", 
                               "RECALL_PLENARY", "COMM_PRERROG", "URGENCY", 
                               "BICAM_SIMMETRY", "BICAM_DISAGREE",
                               "EXTRAORD_SITTINGS", "INFORMAL_POWERS") 
     
     
     for (i in 1:nrow(aux.totaliza.prespowers))
     {
      total.highest.unilateral <- 0
      total.positive.unilateral <- 0
      total.positive.bargaining <- 0

      # totaliza os poderes por cada ano-pais
      for (j in 3:(ncol(aux.totaliza.prespowers) - 1))
      {
        if (colnames (aux.totaliza.prespowers) [j]%in%variables.unilateral)
        { 
          if (aux.totaliza.prespowers [i,j] == 1) 
              { total.highest.unilateral <- total.highest.unilateral + 1 }
          if (aux.totaliza.prespowers [i,j] > 0.5) 
              { total.positive.unilateral <- total.positive.unilateral + 1 }
        }  # end-if
        if ( colnames(aux.totaliza.prespowers) [j]%in%variables.bargaining)
        { 
          if (aux.totaliza.prespowers [i,j] > 0.5) 
          { total.positive.bargaining <- total.positive.bargaining + 1 }
        }  # end-if
       
      }  # end-for
      
 #     aux.totaliza.prespowers$highest [i] <- total.highest.unilateral 
 #      aux.totaliza.prespowers$unilateral [i] <- total.positive.unilateral 
 #    aux.totaliza.prespowers$bargaining [i] <- total.positive.bargaining     
      # identifica os resultados (tabela seção 4.3.2.1.4 do texto)
            # Formato simplificado da tabela (menos valores fuzzy)
      if (total.highest.unilateral > 2 )
      {
        if (total.positive.bargaining > 6)
        { aux.totaliza.prespowers$PRESPOWERS [i] <- 1.00}
      }
      if (is.na(aux.totaliza.prespowers$PRESPOWERS [i]))
         #  trata todos os demais casos que não caíram no fuzzy 1
      {
        if (total.positive.unilateral > 2)
        {
          if  (total.positive.bargaining < 7) 
          {aux.totaliza.prespowers$PRESPOWERS [i] <- 0.33}
          else
          {aux.totaliza.prespowers$PRESPOWERS [i] <- 0.75} 
        }
        else
        {
          if  (total.positive.bargaining < 7) 
          {aux.totaliza.prespowers$PRESPOWERS [i] <- 0.00}
          else
          {aux.totaliza.prespowers$PRESPOWERS [i] <- 0.33}   
        }
        } # end-if     
     }  #end-for        
########  Formato anterior da tabela com distribuição de valores fuzzy mais granulada
#      if (total.highest.unilateral > 2 )
#      {
#        if (total.positive.bargaining > 6)
#        { aux.totaliza.prespowers$PRESPOWERS [i] <- 1}
#        else
#        { aux.totaliza.prespowers$PRESPOWERS [i] <- 0.66}
#      }
#      else
#      {
#        if (total.positive.unilateral > 2 ) 
#        {
#          if  (total.positive.bargaining > 6) 
#          {aux.totaliza.prespowers$PRESPOWERS [i] <- 0.88}
#          else
#          {aux.totaliza.prespowers$PRESPOWERS [i] <- 0.66}
#        }
#        else
#        {
#          if  (total.positive.bargaining > 6) 
#          {aux.totaliza.prespowers$PRESPOWERS [i] <- 0.75}
#          else
#            if ( (total.positive.unilateral == 1) | 
#                 (total.positive.unilateral == 2))
#            {
#              if  ((total.positive.bargaining > 0) &
#                   (total.positive.bargaining < 7) )
#              {aux.totaliza.prespowers$PRESPOWERS [i] <- 0.33 }
#              else
#              {aux.totaliza.prespowers$PRESPOWERS [i] <- 0.25 }
#            }
#          else
#          { if ((total.positive.bargaining > 0) &
#                (total.positive.bargaining < 7) ) 
#          {aux.totaliza.prespowers$PRESPOWERS [i] <- 0.25}
#            else
#            {aux.totaliza.prespowers$PRESPOWERS [i] <- 0} 
#          }
#        }  
#        
#     }    
#     }  #end-for             

     

#  filtra os dados para a tabela verdade mesmo ano
dados.filtrados <- data.frame (tabela.verdade.mesmo.ano$CTR, 
                               tabela.verdade.mesmo.ano$YR,
                               tabela.verdade.mesmo.ano$ACCOUNTABILITY)

colnames(dados.filtrados) <- c ("CTR", "YR", "RESULTADO")

dados.fonte <- data.frame (aux.totaliza.prespowers$CTR,
                           aux.totaliza.prespowers$YR,
                           aux.totaliza.prespowers$PRESPOWERS)
colnames(dados.fonte) <- c ("CTR", "YR", "ENTRADA")

eh.numerico <- 1

valores.filtrados <- filtra.valores (dados.filtrados, dados.fonte, eh.numerico)

tabela.verdade.mesmo.ano$PRESPOWER <- valores.filtrados$RESULTADO

###  filtra e carrega na tabela-verdade os dados da condição single.party

dados.filtrados <- data.frame (tabela.verdade.mesmo.ano$CTR, 
                               tabela.verdade.mesmo.ano$YR,
                               tabela.verdade.mesmo.ano$ACCOUNTABILITY)

colnames(dados.filtrados) <- c ("CTR", "YR", "RESULTADO")

dados.fonte <- data.frame (saida.basica$CTR,
                           saida.basica$YR,
                           saida.basica$ind.single.party)
colnames(dados.fonte) <- c ("CTR", "YR", "ENTRADA")

eh.numerico <- 1

valores.filtrados <- filtra.valores (dados.filtrados, dados.fonte, eh.numerico)

tabela.verdade.mesmo.ano$SINGLE_PARTY <- valores.filtrados$RESULTADO


     
     
     
###################################################################################
########################
###########                   carrega tabela-verdade lagged
###########    (só joga a coluna de outcomes e filtra os NA correspondentes)
########################
###################################################################################

tabela.verdade.lagged <- tabela.verdade.mesmo.ano
colnames(tabela.verdade.lagged) [colnames(tabela.verdade.lagged) == 'OUTCOME'] <- 'OUTCOME.LAGGED'


#  filtra dados de outcome goods para os anos-país da tabela-verdade

#  para a tabela verdade mesmo ano
dados.filtrados <- data.frame (tabela.verdade.mesmo.ano$CTR, 
                               tabela.verdade.mesmo.ano$YR,
                               tabela.verdade.mesmo.ano$LEGTHRESHOLD)

colnames(dados.filtrados) <- c ("CTR", "YR", "RESULTADO")
dados.filtrados$RESULTADO <- NA  # evitar arraste indevido de valores da tabela original

dados.fonte <- data.frame (relatorio.analitico$CTR,
                           relatorio.analitico$YR,
                           relatorio.analitico$policy.performance.lagged)

colnames(dados.fonte) <- c ("CTR", "YR", "ENTRADA")

eh.numerico <- 1

valores.filtrados <- filtra.valores (dados.filtrados, dados.fonte, eh.numerico)

tabela.verdade.lagged$OUTCOME.LAGGED <- valores.filtrados$RESULTADO


#filtro dos valores que têm NA no outcome (não podem ser considerados)


tabela.verdade.mesmo.ano <- tabela.verdade.mesmo.ano [ !is.na (tabela.verdade.mesmo.ano$OUTCOME),]

tabela.verdade.lagged <- tabela.verdade.lagged [ !is.na (tabela.verdade.lagged$OUTCOME.LAGGED),]


###################################################################################
########################
###########                   carrega matriz de casos acrescentando non-partisan governments
########################
###################################################################################

# a solução contempla apenas um parâmetro crisp set de non-party ministers 
#  (mais de 50% do gabinete). 
# Apenas para informação: média de todos os governos que têm non-partisans
# empirically found mean = 0.2374911 ; found median = 0.1818182


non.partisan.threshold.1 <- 0.5


tabela.verdade.mesmo.ano.ampliada <- tabela.verdade.mesmo.ano
tabela.verdade.mesmo.ano.ampliada$NON_PARTY <- tabela.verdade.mesmo.ano$LEGTHRESHOLD
tabela.verdade.mesmo.ano.ampliada$NON_PARTY <- NA

for (i in 1:(nrow(tabela.verdade.mesmo.ano.ampliada)))
{
#  em princípio, nenhum caso é de governo não-partidário 
#  (ou seja, variavel NON_PARTY = 1)
  tabela.verdade.mesmo.ano.ampliada$NON_PARTY [i] <- 1
  for (j in 1:(nrow(saida.non.partisan)))
  {
# aqui varre a saida de governos com ministros não-partidários. Se encontrar
# um deles E SE for a proporção maior que 50%, marca a variavel com zero     
      if ((tabela.verdade.mesmo.ano.ampliada$CTR [i] == saida.non.partisan$CTR [j]) &
        (tabela.verdade.mesmo.ano.ampliada$YR [i] == saida.non.partisan$YR [j]))
    {  
      if (saida.non.partisan$NON_PARTY_SHARE [j] > non.partisan.threshold.1)
      {tabela.verdade.mesmo.ano.ampliada$NON_PARTY [i] <- 0 }
      else
      {tabela.verdade.mesmo.ano.ampliada$NON_PARTY [i] <- 1}
    }
  } # end-for
} # end-for
tabela.verdade.mesmo.ano.ampliada <- tabela.verdade.mesmo.ano.ampliada [, c(1, 2, 3, 4, 5, 8, 9, 10, 6, 7)]
# reordena as colunas para non-party ficar antes de accountability, para facilidade de leitura
#tabela.verdade.mesmo.ano.ampliada <- tabela.verdade.mesmo.ano.ampliada %>% relocate(ACCOUNTABILITY, .after = NON_PARTY) 


tabela.verdade.lagged.ampliada <- tabela.verdade.lagged
tabela.verdade.lagged.ampliada$NON_PARTY <- tabela.verdade.lagged$LEGTHRESHOLD
tabela.verdade.lagged.ampliada$NON_PARTY <- NA

for (i in 1:(nrow(tabela.verdade.lagged.ampliada)))
{
  #  em princípio, nenhum caso é de governo não-partidário 
  #  (ou seja, variavel NON_PARTY = 1)
  tabela.verdade.lagged.ampliada$NON_PARTY [i] <- 1
    
    for (j in 1:(nrow(saida.non.partisan)))
  {
# aqui varre a saida de governos com ministros não-partidários. Se encontrar
# um deles E SE for a proporção maior que 50%, marca a variavel com zero     
      
      if ((tabela.verdade.lagged.ampliada$CTR [i] == saida.non.partisan$CTR [j]) &
        (tabela.verdade.lagged.ampliada$YR [i] == saida.non.partisan$YR [j]))
    {  
#        tabela.verdade.lagged.ampliada$NON_PARTY [i] <- saida.non.partisan$NON_PARTISAN_FUZZY [j]
      #     solução anterior
      if (saida.non.partisan$NON_PARTY_SHARE [j] > non.partisan.threshold.1)
      {tabela.verdade.lagged.ampliada$NON_PARTY [i] <- 0 }
      else
        { tabela.verdade.lagged.ampliada$NON_PARTY [i] <- 1} 
    }
  } #end-for
} # end-for 
tabela.verdade.lagged.ampliada <- tabela.verdade.lagged.ampliada [, c(1, 2, 3, 4, 5, 8, 9, 10, 6, 7)]
# reordena as colunas para non-party ficar antes de accountability, para facilidade de leitura
#tabela.verdade.lagged.ampliada <- tabela.verdade.lagged.ampliada %>% relocate(ACCOUNTABILITY, .after = NON_PARTY) 


# adapta os nomes das condições ao padrão teórico de QCA 
colnames(tabela.verdade.mesmo.ano.ampliada) <- c('CTR', 'YR', 'POWERFUL_PRES', 'RECONC_PARTY_GOAL', 'ABOVE_40_PCT', 'POLARIZED','SINGLE_PARTY_CAB', 'PARTISAN_CAB', 'ACCOUNTABILITY', 'OUTCOME') 
colnames(tabela.verdade.lagged.ampliada) <- c('CTR', 'YR', 'POWERFUL_PRES', 'RECONC_PARTY_GOAL','ABOVE_40_PCT', 'POLARIZED','SINGLE_PARTY_CAB', 'PARTISAN_CAB', 'ACCOUNTABILITY', 'OUTCOME_LAGGED') 



###################################################################################
########################
###########                   grava excel com todas as planilhas de saida
########################
###################################################################################

# filtra a planilha de saída de governos minoritários
relatorio.analitico <- saida.basica [saida.basica$ind.minority == 1,]


############################################################################################
#  
#  cada uma será uma planilha do arquivo final (planilha.saida é uma named list of dataframes)
############################################################################################


planilha.saida <- list (Totais = final.summary, 
                        Govts_de_Minoria = relatorio.analitico,
                        Subtotais_por_pais = subtotais.pais, 
                        Subtotais_por_ano = subtotais.ano,
                        Subtotais_performance_pais = subtotais.performance.pais,
                        Performance = ind.policy.performance,
                        Min_Nao_Partid = saida.non.partisan,
                        Govt_Nao_Partid = final.summary.non.partisan,
                        Govt_Nao_Minorit = saida.non.minority,
                        Accountability_IDEA = base.IDEA.original,
                        Volatility = base.volatility,
                        Oppositional = base.VDem.oppositional.influence,
                        Particularistic = base.VDem.particularistic.system,
                        Party_goals_confere = aux.partygoals,
                        Informal = base.VDem.informal.powers,
                        Legisl_Powers = base.prespowers.leg,
                        Budget_Powers = base.prespowers.budg,
                        Resumo_Pres_Powers = aux.totaliza.prespowers,
                        Polarization = aux.polarization,
                        Single_party = aux.impr.single.party,
                        Matriz_de_casos = tabela.verdade.mesmo.ano,
                        Matriz_de_casos_lagged = tabela.verdade.lagged,
                        Matriz_de_casos_ampl = tabela.verdade.mesmo.ano.ampliada,
                        Matriz_de_casos_lagged_ampl = tabela.verdade.lagged.ampliada
                        )

##  identifica o filename dos arquivos de saida quando a opção for usar
##  4 variaveis para o indicador de policy performance
if (performance.duas.variaveis)
{nome.planilha.saida <- "planilha.saida.governos.minoritarios.xlsx"
nome.matriz.de.casos.mesmo.ano.ampliada <- "matriz.de.casos.mesmo.ano.ampliada.csv"
nome.matriz.de.casos.lagged.ampliada <- "matriz.de.casos.lagged.ampliada.csv"
} else
#else
{ nome.planilha.saida <- "planilha.saida.governos.minoritarios.perf4v.xlsx" 
nome.matriz.de.casos.mesmo.ano.ampliada <- "matriz.de.casos.mesmo.ano.ampliada.perf4v.csv"
nome.matriz.de.casos.lagged.ampliada <- "matriz.de.casos.lagged.ampliada.perf4v.csv"
}
# endif

write_xlsx(
  planilha.saida,
  path = nome.planilha.saida,
  col_names = TRUE #,
  #  format_headers = TRUE,
  # use_zip64 = TRUE
)



###################################################################################
########################
###########                   grava csv com todas as tabelas-verdade 
###########                   (denominadas matriz de casos, porque a 
###########                    rigor não são tabela-verdade)
###########                   com a primeira coluna sendo o "nome do caso" (concatenando ano-país)
########################
###################################################################################

###  impressão da tabela sem a variável partisan cabinet foi desativada
###  por desnecessária (o tratamento da carga ou nao de variaveis vai ser feito
###   nos scripts posteriores)
#CASE_NAME <- as.data.frame(paste (tabela.verdade.mesmo.ano$CTR, as.character(tabela.verdade.mesmo.ano$YR)))

#matriz.de.casos.mesmo.ano <- as.data.frame ( c(CASE_NAME, tabela.verdade.mesmo.ano [, 3:ncol(tabela.verdade.mesmo.ano) ]))
#colnames(matriz.de.casos.mesmo.ano) [1] <- "CASE_NAME"

#write.csv(
#  matriz.de.casos.mesmo.ano,
#  file = "matriz.de.casos.mesmo.ano.csv", 
#  row.names =  FALSE
  #  col_names = TRUE,
  #  format_headers = TRUE,
  # use_zip64 = TRUE
#)


#CASE_NAME <- as.data.frame(paste (tabela.verdade.lagged$CTR, as.character(tabela.verdade.lagged$YR)))

#matriz.de.casos.lagged <- as.data.frame ( c(CASE_NAME, tabela.verdade.lagged [, 3:ncol(tabela.verdade.lagged) ]))
#colnames(matriz.de.casos.lagged) [1] <- "CASE_NAME"

#write.csv(
#  matriz.de.casos.lagged,
#  file = "matriz.de.casos.lagged.csv",
#  row.names = FALSE
#  col_names = TRUE,
  #  format_headers = TRUE,
  # use_zip64 = TRUE
#)


CASE_NAME <- as.data.frame(paste (tabela.verdade.mesmo.ano.ampliada$CTR, as.character(tabela.verdade.mesmo.ano.ampliada$YR)))

matriz.de.casos.mesmo.ano.ampliada <- as.data.frame ( c(CASE_NAME, tabela.verdade.mesmo.ano.ampliada [, 3:ncol(tabela.verdade.mesmo.ano.ampliada) ]))
colnames(matriz.de.casos.mesmo.ano.ampliada) [1] <- "CASE_NAME"

write.csv(
  matriz.de.casos.mesmo.ano.ampliada,
  file = nome.matriz.de.casos.mesmo.ano.ampliada,  
  row.names =  FALSE
  #  col_names = TRUE,
  #  format_headers = TRUE,
  # use_zip64 = TRUE
)


CASE_NAME <- as.data.frame(paste (tabela.verdade.lagged.ampliada$CTR, as.character(tabela.verdade.lagged.ampliada$YR)))

matriz.de.casos.lagged.ampliada <- as.data.frame ( c(CASE_NAME, tabela.verdade.lagged.ampliada [, 3:ncol(tabela.verdade.lagged.ampliada) ]))
colnames(matriz.de.casos.lagged.ampliada) [1] <- "CASE_NAME"

write.csv(
  matriz.de.casos.lagged.ampliada,
  file = nome.matriz.de.casos.lagged.ampliada,
  row.names = FALSE
  #  col_names = TRUE,
  #  format_headers = TRUE,
  # use_zip64 = TRUE
)
############################################################################################
#  bzbzbzbz
############################################################################################


